]>
Commit | Line | Data |
---|---|---|
db137867 AC |
1 | /* |
2 | * ircd-ratbox: A slightly useful ircd. | |
3 | * win32.c: select() compatible network routines. | |
4 | * | |
5 | * Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center | |
6 | * Copyright (C) 1996-2002 Hybrid Development Team | |
7 | * Copyright (C) 2001 Adrian Chadd <adrian@creative.net.au> | |
8 | * Copyright (C) 2005-2006 Aaron Sethman <androsyn@ratbox.org> | |
9 | * Copyright (C) 2002-2006 ircd-ratbox development team | |
10 | * | |
11 | * This program is free software; you can redistribute it and/or modify | |
12 | * it under the terms of the GNU General Public License as published by | |
13 | * the Free Software Foundation; either version 2 of the License, or | |
14 | * (at your option) any later version. | |
15 | * | |
16 | * This program is distributed in the hope that it will be useful, | |
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
19 | * GNU General Public License for more details. | |
20 | * | |
21 | * You should have received a copy of the GNU General Public License | |
22 | * along with this program; if not, write to the Free Software | |
23 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 | |
24 | * USA | |
25 | * | |
3202e249 | 26 | * $Id: win32.c 26092 2008-09-19 15:13:52Z androsyn $ |
db137867 AC |
27 | */ |
28 | ||
fe037171 EM |
29 | #include <librb_config.h> |
30 | #include <rb_lib.h> | |
db137867 AC |
31 | #include <commio-int.h> |
32 | ||
3202e249 | 33 | #ifdef _WIN32 |
db137867 AC |
34 | |
35 | static HWND hwnd; | |
36 | ||
37 | #define WM_SOCKET WM_USER | |
38 | /* | |
39 | * having gettimeofday is nice... | |
40 | */ | |
41 | ||
42 | typedef union | |
43 | { | |
44 | unsigned __int64 ft_i64; | |
45 | FILETIME ft_val; | |
46 | } FT_t; | |
47 | ||
48 | #ifdef __GNUC__ | |
49 | #define Const64(x) x##LL | |
50 | #else | |
51 | #define Const64(x) x##i64 | |
52 | #endif | |
53 | /* Number of 100 nanosecond units from 1/1/1601 to 1/1/1970 */ | |
54 | #define EPOCH_BIAS Const64(116444736000000000) | |
55 | ||
56 | pid_t | |
3202e249 | 57 | rb_getpid() |
db137867 AC |
58 | { |
59 | return GetCurrentProcessId(); | |
60 | } | |
61 | ||
62 | ||
63 | int | |
64 | rb_gettimeofday(struct timeval *tp, void *not_used) | |
65 | { | |
66 | FT_t ft; | |
67 | ||
68 | /* this returns time in 100-nanosecond units (i.e. tens of usecs) */ | |
69 | GetSystemTimeAsFileTime(&ft.ft_val); | |
70 | ||
71 | /* seconds since epoch */ | |
3202e249 | 72 | tp->tv_sec = (long)((ft.ft_i64 - EPOCH_BIAS) / Const64(10000000)); |
db137867 AC |
73 | |
74 | /* microseconds remaining */ | |
3202e249 | 75 | tp->tv_usec = (long)((ft.ft_i64 / Const64(10)) % Const64(1000000)); |
db137867 AC |
76 | |
77 | return 0; | |
78 | } | |
79 | ||
80 | ||
81 | pid_t | |
82 | rb_spawn_process(const char *path, const char **argv) | |
83 | { | |
84 | PROCESS_INFORMATION pi; | |
85 | STARTUPINFO si; | |
86 | char cmd[MAX_PATH]; | |
87 | memset(&pi, 0, sizeof(pi)); | |
88 | memset(&si, 0, sizeof(si)); | |
89 | rb_strlcpy(cmd, path, sizeof(cmd)); | |
90 | if(CreateProcess(cmd, cmd, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi) == FALSE) | |
91 | return -1; | |
92 | ||
93 | return (pi.dwProcessId); | |
94 | } | |
95 | ||
96 | pid_t | |
3202e249 | 97 | rb_waitpid(int pid, int *status, int flags) |
db137867 AC |
98 | { |
99 | DWORD timeout = (flags & WNOHANG) ? 0 : INFINITE; | |
100 | HANDLE hProcess; | |
101 | DWORD waitcode; | |
102 | ||
103 | hProcess = OpenProcess(PROCESS_ALL_ACCESS, TRUE, pid); | |
104 | if(hProcess) | |
105 | { | |
106 | waitcode = WaitForSingleObject(hProcess, timeout); | |
107 | if(waitcode == WAIT_TIMEOUT) | |
108 | { | |
109 | CloseHandle(hProcess); | |
110 | return 0; | |
111 | } | |
112 | else if(waitcode == WAIT_OBJECT_0) | |
113 | { | |
114 | if(GetExitCodeProcess(hProcess, &waitcode)) | |
115 | { | |
3202e249 | 116 | *status = (int)((waitcode & 0xff) << 8); |
db137867 AC |
117 | CloseHandle(hProcess); |
118 | return pid; | |
119 | } | |
120 | } | |
121 | CloseHandle(hProcess); | |
122 | } | |
123 | else | |
124 | errno = ECHILD; | |
125 | ||
126 | return -1; | |
127 | } | |
128 | ||
129 | int | |
3202e249 | 130 | rb_setenv(const char *name, const char *value, int overwrite) |
db137867 AC |
131 | { |
132 | char *buf; | |
133 | int len; | |
134 | if(!overwrite) | |
135 | { | |
136 | if((buf = getenv(name)) != NULL) | |
137 | { | |
138 | if(strlen(buf) > 0) | |
139 | { | |
140 | return 0; | |
141 | } | |
142 | } | |
143 | } | |
144 | if(name == NULL || value == NULL) | |
145 | return -1; | |
146 | len = strlen(name) + strlen(value) + 5; | |
147 | buf = rb_malloc(len); | |
5203cba5 | 148 | snprintf(buf, len, "%s=%s", name, value); |
db137867 AC |
149 | len = putenv(buf); |
150 | rb_free(buf); | |
151 | return (len); | |
152 | } | |
153 | ||
154 | int | |
3202e249 | 155 | rb_kill(int pid, int sig) |
db137867 AC |
156 | { |
157 | HANDLE hProcess; | |
db137867 | 158 | int ret = -1; |
030272f3 | 159 | hProcess = OpenProcess(PROCESS_ALL_ACCESS, TRUE, pid); |
55abcbb2 | 160 | |
db137867 AC |
161 | if(hProcess) |
162 | { | |
163 | switch (sig) | |
164 | { | |
165 | case 0: | |
166 | ret = 0; | |
167 | break; | |
168 | ||
169 | default: | |
170 | if(TerminateProcess(hProcess, sig)) | |
171 | ret = 0; | |
172 | break; | |
173 | } | |
174 | CloseHandle(hProcess); | |
175 | } | |
176 | else | |
177 | errno = EINVAL; | |
178 | ||
179 | return ret; | |
180 | ||
181 | ||
182 | } | |
183 | ||
3202e249 VY |
184 | /* |
185 | * packet format is | |
186 | uint32_t magic | |
187 | uint8_t protocol count | |
188 | WSAPROTOCOL_INFO * count | |
189 | size_t datasize | |
190 | data | |
55abcbb2 | 191 | |
3202e249 VY |
192 | */ |
193 | ||
194 | static int | |
195 | make_wsaprotocol_info(pid_t process, rb_fde_t *F, WSAPROTOCOL_INFO * inf) | |
db137867 AC |
196 | { |
197 | WSAPROTOCOL_INFO info; | |
3202e249 VY |
198 | if(!WSADuplicateSocket((SOCKET) rb_get_fd(F), process, &info)) |
199 | { | |
200 | memcpy(inf, &info, sizeof(WSAPROTOCOL_INFO)); | |
201 | return 1; | |
202 | } | |
db137867 AC |
203 | return 0; |
204 | } | |
205 | ||
3202e249 VY |
206 | static rb_fde_t * |
207 | make_fde_from_wsaprotocol_info(void *data) | |
208 | { | |
209 | WSAPROTOCOL_INFO *info = data; | |
210 | SOCKET t; | |
211 | t = WSASocket(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, info, 0, 0); | |
212 | if(t == INVALID_SOCKET) | |
213 | { | |
214 | rb_get_errno(); | |
215 | return NULL; | |
216 | } | |
217 | return rb_open(t, RB_FD_SOCKET, "remote_socket"); | |
218 | } | |
219 | ||
220 | static uint8_t fd_buf[16384]; | |
221 | #define MAGIC_CONTROL 0xFF0ACAFE | |
222 | ||
223 | int | |
224 | rb_send_fd_buf(rb_fde_t *xF, rb_fde_t **F, int count, void *data, size_t datasize, pid_t pid) | |
225 | { | |
226 | size_t bufsize = | |
227 | sizeof(uint32_t) + sizeof(uint8_t) + (sizeof(WSAPROTOCOL_INFO) * (size_t)count) + | |
228 | sizeof(size_t) + datasize; | |
229 | int i; | |
230 | uint32_t magic = MAGIC_CONTROL; | |
231 | void *ptr; | |
232 | if(count > 4) | |
233 | { | |
234 | errno = EINVAL; | |
235 | return -1; | |
236 | } | |
237 | if(bufsize > sizeof(fd_buf)) | |
238 | { | |
239 | errno = EINVAL; | |
240 | return -1; | |
241 | } | |
242 | memset(fd_buf, 0, sizeof(fd_buf)); | |
243 | ||
244 | ptr = fd_buf; | |
245 | memcpy(ptr, &magic, sizeof(magic)); | |
246 | ptr = (void *)((uintptr_t)ptr + (uintptr_t)sizeof(magic)); | |
247 | *((uint8_t *)ptr) = count; | |
248 | ptr = (void *)((uintptr_t)ptr + (uintptr_t)sizeof(uint8_t)); | |
249 | ||
250 | for(i = 0; i < count; i++) | |
251 | { | |
252 | make_wsaprotocol_info(pid, F[i], (WSAPROTOCOL_INFO *) ptr); | |
253 | ptr = (void *)((uintptr_t)ptr + (uintptr_t)sizeof(WSAPROTOCOL_INFO)); | |
254 | } | |
255 | memcpy(ptr, &datasize, sizeof(size_t)); | |
256 | ptr = (void *)((uintptr_t)ptr + (uintptr_t)sizeof(size_t)); | |
257 | memcpy(ptr, data, datasize); | |
258 | return rb_write(xF, fd_buf, bufsize); | |
259 | } | |
260 | ||
261 | #ifdef MYMIN | |
262 | #undef MYMIN | |
263 | #endif | |
264 | #define MYMIN(a, b) ((a) < (b) ? (a) : (b)) | |
265 | ||
266 | int | |
267 | rb_recv_fd_buf(rb_fde_t *F, void *data, size_t datasize, rb_fde_t **xF, int nfds) | |
268 | { | |
269 | size_t minsize = sizeof(uint32_t) + sizeof(uint8_t) + sizeof(size_t); | |
270 | size_t datalen; | |
271 | ssize_t retlen; | |
272 | uint32_t magic; | |
273 | uint8_t count; | |
274 | unsigned int i; | |
275 | void *ptr; | |
276 | ssize_t ret; | |
277 | memset(fd_buf, 0, sizeof(fd_buf)); /* some paranoia here... */ | |
278 | ret = rb_read(F, fd_buf, sizeof(fd_buf)); | |
279 | if(ret <= 0) | |
280 | { | |
281 | return ret; | |
282 | } | |
283 | if(ret < (ssize_t) minsize) | |
284 | { | |
285 | errno = EINVAL; | |
286 | return -1; | |
287 | } | |
288 | ptr = fd_buf; | |
289 | memcpy(&magic, ptr, sizeof(uint32_t)); | |
290 | if(magic != MAGIC_CONTROL) | |
291 | { | |
292 | errno = EAGAIN; | |
293 | return -1; | |
294 | } | |
295 | ptr = (void *)((uintptr_t)ptr + (uintptr_t)sizeof(uint32_t)); | |
296 | memcpy(&count, ptr, sizeof(uint8_t)); | |
297 | ptr = (void *)((uintptr_t)ptr + (uintptr_t)sizeof(uint8_t)); | |
298 | for(i = 0; i < count && i < (unsigned int)nfds; i++) | |
299 | { | |
300 | rb_fde_t *tF = make_fde_from_wsaprotocol_info(ptr); | |
301 | if(tF == NULL) | |
302 | return -1; | |
303 | xF[i] = tF; | |
304 | ptr = (void *)((uintptr_t)ptr + (uintptr_t)sizeof(WSAPROTOCOL_INFO)); | |
305 | } | |
306 | memcpy(&datalen, ptr, sizeof(size_t)); | |
307 | ptr = (void *)((uintptr_t)ptr + (uintptr_t)sizeof(size_t)); | |
308 | retlen = MYMIN(datalen, datasize); | |
309 | memcpy(data, ptr, datalen); | |
310 | return retlen; | |
311 | } | |
db137867 AC |
312 | |
313 | static LRESULT CALLBACK | |
314 | rb_process_events(HWND nhwnd, UINT umsg, WPARAM wparam, LPARAM lparam) | |
315 | { | |
316 | rb_fde_t *F; | |
317 | PF *hdl; | |
318 | void *data; | |
319 | switch (umsg) | |
320 | { | |
321 | case WM_SOCKET: | |
322 | { | |
323 | F = rb_find_fd(wparam); | |
324 | ||
325 | if(F != NULL && IsFDOpen(F)) | |
326 | { | |
327 | switch (WSAGETSELECTEVENT(lparam)) | |
328 | { | |
329 | case FD_ACCEPT: | |
330 | case FD_CLOSE: | |
331 | case FD_READ: | |
332 | { | |
333 | if((hdl = F->read_handler) != NULL) | |
334 | { | |
335 | F->read_handler = NULL; | |
336 | data = F->read_data; | |
337 | F->read_data = NULL; | |
338 | hdl(F, data); | |
339 | } | |
340 | break; | |
341 | } | |
342 | ||
343 | case FD_CONNECT: | |
344 | case FD_WRITE: | |
345 | { | |
346 | if((hdl = F->write_handler) != NULL) | |
347 | { | |
348 | F->write_handler = NULL; | |
349 | data = F->write_data; | |
350 | F->write_data = NULL; | |
351 | hdl(F, data); | |
352 | } | |
353 | } | |
354 | } | |
355 | ||
356 | } | |
357 | return 0; | |
358 | } | |
359 | case WM_DESTROY: | |
360 | { | |
361 | PostQuitMessage(0); | |
362 | return 0; | |
363 | } | |
364 | ||
365 | default: | |
366 | return DefWindowProc(nhwnd, umsg, wparam, lparam); | |
367 | } | |
368 | return 0; | |
369 | } | |
370 | ||
371 | int | |
372 | rb_init_netio_win32(void) | |
373 | { | |
374 | /* this muchly sucks, but i'm too lazy to do overlapped i/o, maybe someday... -androsyn */ | |
375 | WNDCLASS wc; | |
376 | static const char *classname = "ircd-ratbox-class"; | |
377 | ||
378 | wc.style = 0; | |
379 | wc.lpfnWndProc = (WNDPROC) rb_process_events; | |
380 | wc.cbClsExtra = 0; | |
381 | wc.cbWndExtra = 0; | |
382 | wc.hIcon = NULL; | |
383 | wc.hCursor = NULL; | |
384 | wc.hbrBackground = NULL; | |
385 | wc.lpszMenuName = NULL; | |
386 | wc.lpszClassName = classname; | |
387 | wc.hInstance = GetModuleHandle(NULL); | |
388 | ||
389 | if(!RegisterClass(&wc)) | |
390 | rb_lib_die("cannot register window class"); | |
391 | ||
392 | hwnd = CreateWindow(classname, classname, WS_POPUP, CW_USEDEFAULT, | |
393 | CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, | |
394 | (HWND) NULL, (HMENU) NULL, wc.hInstance, NULL); | |
395 | if(!hwnd) | |
396 | rb_lib_die("could not create window"); | |
397 | return 0; | |
398 | } | |
399 | ||
400 | void | |
401 | rb_sleep(unsigned int seconds, unsigned int useconds) | |
402 | { | |
3202e249 VY |
403 | DWORD msec = seconds * 1000;; |
404 | Sleep(msec); | |
db137867 AC |
405 | } |
406 | ||
407 | int | |
3202e249 | 408 | rb_setup_fd_win32(rb_fde_t *F) |
db137867 AC |
409 | { |
410 | if(F == NULL) | |
411 | return 0; | |
412 | ||
413 | SetHandleInformation((HANDLE) F->fd, HANDLE_FLAG_INHERIT, 0); | |
414 | switch (F->type) | |
415 | { | |
416 | case RB_FD_SOCKET: | |
417 | { | |
418 | u_long nonb = 1; | |
419 | if(ioctlsocket((SOCKET) F->fd, FIONBIO, &nonb) == -1) | |
420 | { | |
421 | rb_get_errno(); | |
422 | return 0; | |
423 | } | |
424 | return 1; | |
425 | } | |
426 | default: | |
427 | return 1; | |
428 | ||
429 | } | |
430 | } | |
431 | ||
432 | void | |
3202e249 | 433 | rb_setselect_win32(rb_fde_t *F, unsigned int type, PF * handler, void *client_data) |
db137867 AC |
434 | { |
435 | int old_flags = F->pflags; | |
436 | ||
437 | lrb_assert(IsFDOpen(F)); | |
438 | ||
439 | /* Update the list, even though we're not using it .. */ | |
440 | if(type & RB_SELECT_READ) | |
441 | { | |
442 | if(handler != NULL) | |
443 | F->pflags |= FD_CLOSE | FD_READ | FD_ACCEPT; | |
444 | else | |
445 | F->pflags &= ~(FD_CLOSE | FD_READ | FD_ACCEPT); | |
446 | F->read_handler = handler; | |
447 | F->read_data = client_data; | |
448 | } | |
449 | ||
450 | if(type & RB_SELECT_WRITE) | |
451 | { | |
452 | if(handler != NULL) | |
453 | F->pflags |= FD_WRITE | FD_CONNECT; | |
454 | else | |
455 | F->pflags &= ~(FD_WRITE | FD_CONNECT); | |
456 | F->write_handler = handler; | |
457 | F->write_data = client_data; | |
458 | } | |
459 | ||
460 | if(old_flags == 0 && F->pflags == 0) | |
461 | return; | |
462 | ||
463 | if(F->pflags != old_flags) | |
464 | { | |
465 | WSAAsyncSelect(F->fd, hwnd, WM_SOCKET, F->pflags); | |
466 | } | |
467 | ||
468 | } | |
469 | ||
470 | ||
471 | static int has_set_timer = 0; | |
472 | ||
473 | int | |
474 | rb_select_win32(long delay) | |
475 | { | |
476 | MSG msg; | |
477 | if(has_set_timer == 0) | |
478 | { | |
479 | /* XXX should probably have this handle all the events | |
55abcbb2 | 480 | * instead of busy looping |
db137867 AC |
481 | */ |
482 | SetTimer(hwnd, 0, delay, NULL); | |
483 | has_set_timer = 1; | |
484 | } | |
485 | ||
486 | if(GetMessage(&msg, NULL, 0, 0) == FALSE) | |
487 | { | |
488 | rb_lib_die("GetMessage failed..byebye"); | |
489 | } | |
490 | rb_set_time(); | |
491 | ||
492 | DispatchMessage(&msg); | |
493 | return RB_OK; | |
494 | } | |
495 | ||
496 | #ifdef strerror | |
497 | #undef strerror | |
498 | #endif | |
499 | ||
3202e249 VY |
500 | static const char * |
501 | _rb_strerror(int error) | |
db137867 AC |
502 | { |
503 | switch (error) | |
504 | { | |
505 | case 0: | |
506 | return "Success"; | |
507 | case WSAEINTR: | |
508 | return "Interrupted system call"; | |
509 | case WSAEBADF: | |
510 | return "Bad file number"; | |
511 | case WSAEACCES: | |
512 | return "Permission denied"; | |
513 | case WSAEFAULT: | |
514 | return "Bad address"; | |
515 | case WSAEINVAL: | |
516 | return "Invalid argument"; | |
517 | case WSAEMFILE: | |
518 | return "Too many open sockets"; | |
519 | case WSAEWOULDBLOCK: | |
520 | return "Operation would block"; | |
521 | case WSAEINPROGRESS: | |
522 | return "Operation now in progress"; | |
523 | case WSAEALREADY: | |
524 | return "Operation already in progress"; | |
525 | case WSAENOTSOCK: | |
526 | return "Socket operation on non-socket"; | |
527 | case WSAEDESTADDRREQ: | |
528 | return "Destination address required"; | |
529 | case WSAEMSGSIZE: | |
530 | return "Message too long"; | |
531 | case WSAEPROTOTYPE: | |
532 | return "Protocol wrong type for socket"; | |
533 | case WSAENOPROTOOPT: | |
534 | return "Bad protocol option"; | |
535 | case WSAEPROTONOSUPPORT: | |
536 | return "Protocol not supported"; | |
537 | case WSAESOCKTNOSUPPORT: | |
538 | return "Socket type not supported"; | |
539 | case WSAEOPNOTSUPP: | |
540 | return "Operation not supported on socket"; | |
541 | case WSAEPFNOSUPPORT: | |
542 | return "Protocol family not supported"; | |
543 | case WSAEAFNOSUPPORT: | |
544 | return "Address family not supported"; | |
545 | case WSAEADDRINUSE: | |
546 | return "Address already in use"; | |
547 | case WSAEADDRNOTAVAIL: | |
548 | return "Can't assign requested address"; | |
549 | case WSAENETDOWN: | |
550 | return "Network is down"; | |
551 | case WSAENETUNREACH: | |
552 | return "Network is unreachable"; | |
553 | case WSAENETRESET: | |
554 | return "Net connection reset"; | |
555 | case WSAECONNABORTED: | |
556 | return "Software caused connection abort"; | |
557 | case WSAECONNRESET: | |
558 | return "Connection reset by peer"; | |
559 | case WSAENOBUFS: | |
560 | return "No buffer space available"; | |
561 | case WSAEISCONN: | |
562 | return "Socket is already connected"; | |
563 | case WSAENOTCONN: | |
564 | return "Socket is not connected"; | |
565 | case WSAESHUTDOWN: | |
566 | return "Can't send after socket shutdown"; | |
567 | case WSAETOOMANYREFS: | |
568 | return "Too many references, can't splice"; | |
569 | case WSAETIMEDOUT: | |
570 | return "Connection timed out"; | |
571 | case WSAECONNREFUSED: | |
572 | return "Connection refused"; | |
573 | case WSAELOOP: | |
574 | return "Too many levels of symbolic links"; | |
575 | case WSAENAMETOOLONG: | |
576 | return "File name too long"; | |
577 | case WSAEHOSTDOWN: | |
578 | return "Host is down"; | |
579 | case WSAEHOSTUNREACH: | |
580 | return "No route to host"; | |
581 | case WSAENOTEMPTY: | |
582 | return "Directory not empty"; | |
583 | case WSAEPROCLIM: | |
584 | return "Too many processes"; | |
585 | case WSAEUSERS: | |
586 | return "Too many users"; | |
587 | case WSAEDQUOT: | |
588 | return "Disc quota exceeded"; | |
589 | case WSAESTALE: | |
590 | return "Stale NFS file handle"; | |
591 | case WSAEREMOTE: | |
592 | return "Too many levels of remote in path"; | |
593 | case WSASYSNOTREADY: | |
594 | return "Network system is unavailable"; | |
595 | case WSAVERNOTSUPPORTED: | |
596 | return "Winsock version out of range"; | |
597 | case WSANOTINITIALISED: | |
598 | return "WSAStartup not yet called"; | |
599 | case WSAEDISCON: | |
600 | return "Graceful shutdown in progress"; | |
601 | case WSAHOST_NOT_FOUND: | |
602 | return "Host not found"; | |
603 | case WSANO_DATA: | |
604 | return "No host data of that type was found"; | |
605 | default: | |
606 | return strerror(error); | |
607 | } | |
608 | }; | |
3202e249 VY |
609 | |
610 | char * | |
611 | rb_strerror(int error) | |
612 | { | |
613 | static char buf[128]; | |
614 | rb_strlcpy(buf, _rb_strerror(error), sizeof(buf)); | |
615 | return buf; | |
616 | } | |
db137867 AC |
617 | #else /* win32 not supported */ |
618 | int | |
619 | rb_init_netio_win32(void) | |
620 | { | |
621 | errno = ENOSYS; | |
622 | return -1; | |
623 | } | |
624 | ||
625 | void | |
3202e249 | 626 | rb_setselect_win32(rb_fde_t *F, unsigned int type, PF * handler, void *client_data) |
db137867 AC |
627 | { |
628 | errno = ENOSYS; | |
629 | return; | |
630 | } | |
631 | ||
632 | int | |
633 | rb_select_win32(long delay) | |
634 | { | |
635 | errno = ENOSYS; | |
636 | return -1; | |
637 | } | |
638 | ||
639 | int | |
3202e249 | 640 | rb_setup_fd_win32(rb_fde_t *F) |
db137867 AC |
641 | { |
642 | errno = ENOSYS; | |
643 | return -1; | |
644 | } | |
3202e249 | 645 | #endif /* _WIN32 */ |