sim_sock.c

   1 /* sim_sock.c: OS-dependent socket routines
   2
   3    Copyright (c) 2001-2005, Robert M Supnik
   4
   5    Permission is hereby granted, free of charge, to any person obtaining a
   6    copy of this software and associated documentation files (the "Software"),
   7    to deal in the Software without restriction, including without limitation
   8    the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9    and/or sell copies of the Software, and to permit persons to whom the
  10    Software is furnished to do so, subject to the following conditions:
  11
  12    The above copyright notice and this permission notice shall be included in
  13    all copies or substantial portions of the Software.
  14
  15    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18    ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  19    IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21
  22    Except as contained in this notice, the name of Robert M Supnik shall not be
  23    used in advertising or otherwise to promote the sale, use or other dealings
  24    in this Software without prior written authorization from Robert M Supnik.
  25
  26    19-Nov-05    RMS     Added conditional for OpenBSD (from Federico G. Schwindt)
  27    16-Aug-05    RMS     Fixed spurious SIGPIPE signal error in Unix
  28    14-Apr-05    RMS     Added WSAEINPROGRESS test (from Tim Riker)
  29    09-Jan-04    RMS     Fixed typing problem in Alpha Unix (found by Tim Chapman)
  30    17-Apr-03    RMS     Fixed non-implemented version of sim_close_sock
  31                         (found by Mark Pizzolato)
  32    17-Dec-02    RMS     Added sim_connect_socket, sim_create_socket
  33    08-Oct-02    RMS     Revised for .NET compatibility
  34    22-Aug-02    RMS     Changed calling sequence for sim_accept_conn
  35    22-May-02    RMS     Added OS2 EMX support from Holger Veit
  36    06-Feb-02    RMS     Added VMS support from Robert Alan Byer
  37    16-Sep-01    RMS     Added Macintosh support from Peter Schorn
  38    02-Sep-01    RMS     Fixed UNIX bugs found by Mirian Lennox and Tom Markson
  39 */
  40
  41 #include "sim_defs.h"
  42 #include "sim_sock.h"
  43 #include <signal.h>
  44
  45 /* OS dependent routines
  46
  47    sim_master_sock      create master socket
  48    sim_accept_conn      accept connection
  49    sim_read_sock        read from socket
  50    sim_write_sock       write from socket
  51    sim_close_sock       close socket
  52    sim_setnonblock      set socket non-blocking
  53    sim_msg_sock         send message to socket
  54 */
  55
  56 int32 sim_sock_cnt = 0;
  57
  58 /* First, all the non-implemented versions */
  59
  60 #if defined (__OS2__) && !defined (__EMX__)
  61
  62 SOCKET sim_master_sock (int32 port)
  63 {
  64 return INVALID_SOCKET;
  65 }
  66
  67 SOCKET sim_connect_sock (int32 ip, int32 port)
  68 {
  69 return INVALID_SOCKET;
  70 }
  71
  72 SOCKET sim_accept_conn (SOCKET master, uint32 *ipaddr)
  73 {
  74 return INVALID_SOCKET;
  75 }
  76
  77 int32 sim_read_sock (SOCKET sock, char *buf, int32 nbytes)
  78 {
  79 return -1;
  80 }
  81
  82 int32 sim_write_sock (SOCKET sock, char *msg, int32 nbytes)
  83 {
  84 return 0;
  85 }
  86
  87 void sim_close_sock (SOCKET sock, t_bool master)
  88 {
  89 return;
  90 }
  91
  92 SOCKET sim_setnonblock (SOCKET sock)
  93 {
  94 return SOCKET_ERROR;
  95 }
  96
  97 #else                                                   /* endif unimpl */
  98
  99 /* UNIX, Win32, Macintosh, VMS, OS2 (Berkeley socket) routines */
 100
 101 SOCKET sim_err_sock (SOCKET s, char *emsg, int32 flg)
 102 {
 103 int32 err = WSAGetLastError ();
 104
 105 printf ("Sockets: %s error %d\n", emsg, err);
 106 sim_close_sock (s, flg);
 107 return INVALID_SOCKET;
 108 }
 109
 110 SOCKET sim_create_sock (void)
 111 {
 112 SOCKET newsock;
 113 int32 err;
 114
 115 #if defined (_WIN32)
 116 WORD wVersionRequested;
 117 WSADATA wsaData;
 118 wVersionRequested = MAKEWORD (1, 1);
 119
 120 if (sim_sock_cnt == 0) {
 121     err = WSAStartup (wVersionRequested, &wsaData);     /* start Winsock */
 122     if (err != 0) {
 123         printf ("Winsock: startup error %d\n", err);
 124         return INVALID_SOCKET;
 125         }
 126     }
 127 sim_sock_cnt = sim_sock_cnt + 1;
 128 #endif                                                  /* endif Win32 */
 129 #if defined (SIGPIPE)
 130 signal (SIGPIPE, SIG_IGN);                              /* no pipe signals */
 131 #endif
 132
 133 newsock = socket (AF_INET, SOCK_STREAM, 0);             /* create socket */
 134 if (newsock == INVALID_SOCKET) {                        /* socket error? */
 135     err = WSAGetLastError ();
 136     printf ("Sockets: socket error %d\n", err);
 137     return INVALID_SOCKET;
 138     }
 139 return newsock;
 140 }
 141
 142 SOCKET sim_master_sock (int32 port)
 143 {
 144 SOCKET newsock;
 145 struct sockaddr_in name;
 146 int32 sta;
 147
 148 newsock = sim_create_sock ();                           /* create socket */
 149 if (newsock == INVALID_SOCKET) return newsock;          /* socket error? */
 150
 151 name.sin_family = AF_INET;                              /* name socket */
 152 name.sin_port = htons ((unsigned short) port);          /* insert port */
 153 name.sin_addr.s_addr = htonl (INADDR_ANY);              /* insert addr */
 154
 155 sta = bind (newsock, (struct sockaddr *) &name, sizeof (name));
 156 if (sta == SOCKET_ERROR)                                /* bind error? */
 157     return sim_err_sock (newsock, "bind", 1);
 158 sta = sim_setnonblock (newsock);                        /* set nonblocking */
 159 if (sta == SOCKET_ERROR)                                /* fcntl error? */
 160     return sim_err_sock (newsock, "fcntl", 1);
 161 sta = listen (newsock, 1);                              /* listen on socket */
 162 if (sta == SOCKET_ERROR)                                /* listen error? */
 163     return sim_err_sock (newsock, "listen", 1);
 164 return newsock;                                         /* got it! */
 165 }
 166
 167 SOCKET sim_connect_sock (int32 ip, int32 port)
 168 {
 169 SOCKET newsock;
 170 struct sockaddr_in name;
 171 int32 sta;
 172
 173 newsock = sim_create_sock ();                           /* create socket */
 174 if (newsock == INVALID_SOCKET) return newsock;          /* socket error? */
 175
 176 name.sin_family = AF_INET;                              /* name socket */
 177 name.sin_port = htons ((unsigned short) port);          /* insert port */
 178 name.sin_addr.s_addr = htonl (ip);                      /* insert addr */
 179
 180 sta = sim_setnonblock (newsock);                        /* set nonblocking */
 181 if (sta == SOCKET_ERROR)                                /* fcntl error? */
 182     return sim_err_sock (newsock, "fcntl", 1);
 183 sta = connect (newsock, (struct sockaddr *) &name, sizeof (name));
 184 if ((sta == SOCKET_ERROR) &&
 185     (WSAGetLastError () != WSAEWOULDBLOCK) &&
 186     (WSAGetLastError () != WSAEINPROGRESS))
 187     return sim_err_sock (newsock, "connect", 1);
 188
 189 return newsock;                                         /* got it! */
 190 }
 191
 192 SOCKET sim_accept_conn (SOCKET master, uint32 *ipaddr)
 193 {
 194 int32 sta, err;
 195 #if defined (macintosh) || defined (__linux) || \
 196     defined (__APPLE__) || defined (__OpenBSD__)
 197 socklen_t size;
 198 #elif defined (_WIN32) || defined (__EMX__) ||\
 199      (defined (__ALPHA) && defined (__unix__))
 200 int size;
 201 #else
 202 size_t size;
 203 #endif
 204 SOCKET newsock;
 205 struct sockaddr_in clientname;
 206
 207 if (master == 0) return INVALID_SOCKET;                 /* not attached? */
 208 size = sizeof (clientname);
 209 newsock = accept (master, (struct sockaddr *) &clientname, &size);
 210 if (newsock == INVALID_SOCKET) {                        /* error? */
 211     err = WSAGetLastError ();
 212     if (err != WSAEWOULDBLOCK)
 213         printf ("Sockets: accept error %d\n", err);
 214     return INVALID_SOCKET;
 215     }
 216 if (ipaddr != NULL) *ipaddr = ntohl (clientname.sin_addr.s_addr);
 217
 218 sta = sim_setnonblock (newsock);                        /* set nonblocking */
 219 if (sta == SOCKET_ERROR)                                /* fcntl error? */
 220     return sim_err_sock (newsock, "fcntl", 0);
 221 return newsock;
 222 }
 223
 224 int32 sim_check_conn (SOCKET sock, t_bool rd)
 225 {
 226 fd_set rw_set, er_set;
 227 fd_set *rw_p = &rw_set;
 228 fd_set *er_p = &er_set;
 229 struct timeval tz;
 230
 231 timerclear (&tz);
 232 FD_ZERO (rw_p);
 233 FD_ZERO (er_p);
 234 FD_SET (sock, rw_p);
 235 FD_SET (sock, er_p);
 236 if (rd) select ((int) sock + 1, rw_p, NULL, er_p, &tz);
 237 else select ((int) sock + 1, NULL, rw_p, er_p, &tz);
 238 if (FD_ISSET (sock, rw_p)) return 1;
 239 if (FD_ISSET (sock, er_p)) return -1;
 240 return 0;
 241 }
 242
 243 int32 sim_read_sock (SOCKET sock, char *buf, int32 nbytes)
 244 {
 245 int32 rbytes, err;
 246
 247 rbytes = recv (sock, buf, nbytes, 0);
 248 if (rbytes == 0) return -1;                             /* disconnect */
 249 if (rbytes == SOCKET_ERROR) {
 250     err = WSAGetLastError ();
 251     if (err == WSAEWOULDBLOCK) return 0;                /* no data */
 252     printf ("Sockets: read error %d\n", err);
 253     return -1;
 254     }
 255 return rbytes;
 256 }
 257
 258 int32 sim_write_sock (SOCKET sock, char *msg, int32 nbytes)
 259 {
 260 return send (sock, msg, nbytes, 0);
 261 }
 262
 263 void sim_close_sock (SOCKET sock, t_bool master)
 264 {
 265 #if defined (_WIN32)
 266 closesocket (sock);
 267 if (master) {
 268     sim_sock_cnt = sim_sock_cnt - 1;
 269     if (sim_sock_cnt <= 0) {
 270         WSACleanup ();
 271         sim_sock_cnt = 0;
 272         }
 273     }
 274 #else
 275 close (sock);
 276 #endif
 277 return;
 278 }
 279
 280 #if defined (_WIN32)                                    /* Windows */
 281 SOCKET sim_setnonblock (SOCKET sock)
 282 {
 283 unsigned long non_block = 1;
 284
 285 return ioctlsocket (sock, FIONBIO, &non_block);         /* set nonblocking */
 286 }
 287
 288 #elif defined (VMS)                                     /* VMS */
 289 SOCKET sim_setnonblock (SOCKET sock)
 290 {
 291 int non_block = 1;
 292
 293 return ioctl (sock, FIONBIO, &non_block);               /* set nonblocking */
 294 }
 295
 296 #else                                                   /* Mac, Unix, OS/2 */
 297 int32 sim_setnonblock (SOCKET sock)
 298 {
 299 int32 fl, sta;
 300
 301 fl = fcntl (sock, F_GETFL,0);                           /* get flags */
 302 if (fl == -1) return SOCKET_ERROR;
 303 sta = fcntl (sock, F_SETFL, fl | O_NONBLOCK);           /* set nonblock */
 304 if (sta == -1) return SOCKET_ERROR;
 305 #if !defined (macintosh) && !defined (__EMX__)          /* Unix only */
 306 sta = fcntl (sock, F_SETOWN, getpid());                 /* set ownership */
 307 if (sta == -1) return SOCKET_ERROR;
 308 #endif
 309 return 0;
 310 }
 311
 312 #endif                                                  /* endif !Win32 && !VMS */
 313
 314 #endif                                                  /* end else !implemented */