sdk-core v2026.11.05
PS2 SDK - core tier (build-critical EE/IOP modules)
Loading...
Searching...
No Matches
ps2ip_ps2sdk.c
1/*
2# _____ ___ ____ ___ ____
3# ____| | ____| | | |____|
4# | ___| |____ ___| ____| | \ PS2DEV Open Source Project.
5#-----------------------------------------------------------------------
6# Copyright ps2dev - http://www.ps2dev.org
7# Licenced under Academic Free License version 2.0
8# Review ps2sdk README & LICENSE files for further details.
9*/
10
11#define LIBCGLUE_SYS_SOCKET_NO_ALIASES
12#define LIBCGLUE_ARPA_INET_NO_ALIASES
13#include <ps2sdkapi.h>
14#include <string.h>
15#include <errno.h>
16#include <ps2ipee.h>
17
18_libcglue_fdman_socket_ops_t __ps2ipee_fdman_socket_ops;
19_libcglue_fdman_inet_ops_t __ps2ipee_fdman_inet_ops;
20_libcglue_fdman_fd_ops_t __ps2ipee_fdman_ops_socket;
21
22extern void __ps2ipeeOpsInitializeImpl(void);
23
24__attribute__((constructor))
25static void __ps2ipeeOpsInitialize(void)
26{
27 __ps2ipeeOpsInitializeImpl();
28}
29
30int __ps2ipeeSocketHelper(_libcglue_fdman_fd_info_t *info, int domain, int type, int protocol)
31{
32 int iop_fd;
33
34 iop_fd = lwip_socket(domain, type, protocol);
35 if (iop_fd < 0)
36 {
37 return -errno;
38 }
39 info->userdata = (void *)(uiptr)(u32)iop_fd;
40 info->ops = &__ps2ipee_fdman_ops_socket;
41 return 0;
42}
43
44int __ps2ipeeGetFdHelper(void *userdata)
45{
46 return (int)(u32)(uiptr)userdata;
47}
48
49/* Real lwip_addr_t is `unsigned long` (lwip's arch/cc.h port config for
50 * this platform), while _libcglue_fdman_inet_addr_cb_t (ps2sdkapi.h)
51 * is `u32` - `unsigned int`. Both are 32 bits wide, but distinct C
52 * types (a genuine, real, pre-existing platform-level mismatch, not
53 * something this session introduced), so lwip's real ipaddr_addr can't
54 * be assigned to the fdman slot directly - same
55 * "incompatible pointer type" pattern already hit and fixed for
56 * several other fdman callbacks this session, one line adapter. */
57u32 __ps2ipeeInetAddrHelper(const char *cp)
58{
59 return (u32)ipaddr_addr(cp);
60}
61
62int __ps2ipeeFcntlfsetflHelper(void *userdata, int newfl)
63{
64 int fd, res;
65 u32 val;
66
67 fd = __ps2ipeeGetFdHelper(userdata);
68
69 if (fd < 0)
70 {
71 return fd;
72 }
73
74 val = (newfl & O_NONBLOCK) ? 1 : 0;
75 res = lwip_ioctl(fd, FIONBIO, &val);
76 if (res < 0)
77 {
78 return -ENFILE;
79 }
80 return res;
81}
82
83int __ps2ipeeAcceptHelper(void *userdata, _libcglue_fdman_fd_info_t *info, struct sockaddr *addr, socklen_t *addrlen)
84{
85 int fd, new_fd;
86
87 fd = __ps2ipeeGetFdHelper(userdata);
88
89 if (fd < 0)
90 {
91 return fd;
92 }
93
94 new_fd = lwip_accept(fd, addr, addrlen);
95 if (new_fd < 0)
96 {
97 return -errno;
98 }
99 info->userdata = (void *)(uiptr)(u32)new_fd;
100 info->ops = &__ps2ipee_fdman_ops_socket;
101 return 0;
102}
103
104int __ps2ipeeBindHelper(void *userdata, const struct sockaddr *name, socklen_t namelen)
105{
106 int fd, res;
107
108 fd = __ps2ipeeGetFdHelper(userdata);
109
110 if (fd < 0)
111 {
112 return fd;
113 }
114
115 res = lwip_bind(fd, name, namelen);
116 if (res < 0)
117 {
118 return -errno;
119 }
120 return res;
121}
122
123int __ps2ipeeCloseHelper(void *userdata)
124{
125 int fd, res;
126
127 fd = __ps2ipeeGetFdHelper(userdata);
128
129 if (fd < 0)
130 {
131 return fd;
132 }
133
134 res = lwip_close(fd);
135 if (res < 0)
136 {
137 return -errno;
138 }
139 return res;
140}
141
142int __ps2ipeeConnectHelper(void *userdata, const struct sockaddr *name, socklen_t namelen)
143{
144 int fd, res;
145
146 fd = __ps2ipeeGetFdHelper(userdata);
147
148 if (fd < 0)
149 {
150 return fd;
151 }
152
153 res = lwip_connect(fd, name, namelen);
154 if (res < 0)
155 {
156 return -errno;
157 }
158 return res;
159}
160
161int __ps2ipeeListenHelper(void *userdata, int backlog)
162{
163 int fd, res;
164
165 fd = __ps2ipeeGetFdHelper(userdata);
166
167 if (fd < 0)
168 {
169 return fd;
170 }
171
172 res = lwip_listen(fd, backlog);
173 if (res < 0)
174 {
175 return -errno;
176 }
177 return res;
178}
179
180int __ps2ipeeRecvHelper(void *userdata, void *mem, size_t len, int flags)
181{
182 int fd, res;
183
184 fd = __ps2ipeeGetFdHelper(userdata);
185
186 if (fd < 0)
187 {
188 return fd;
189 }
190
191 res = lwip_recv(fd, mem, len, flags);
192 if (res < 0)
193 {
194 return -errno;
195 }
196 return res;
197}
198
199int __ps2ipeeRecvfromHelper(void *userdata, void *mem, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
200{
201 int fd, res;
202
203 fd = __ps2ipeeGetFdHelper(userdata);
204
205 if (fd < 0)
206 {
207 return fd;
208 }
209
210 res = lwip_recvfrom(fd, mem, len, flags, from, fromlen);
211 if (res < 0)
212 {
213 return -errno;
214 }
215 return res;
216}
217
218int __ps2ipeeRecvmsgHelper(void *userdata, struct msghdr *msg, int flags)
219{
220 // TODO
221 return -1;
222}
223
224int __ps2ipeeSendHelper(void *userdata, const void *dataptr, size_t size, int flags)
225{
226 int fd, res;
227
228 fd = __ps2ipeeGetFdHelper(userdata);
229
230 if (fd < 0)
231 {
232 return fd;
233 }
234
235 res = lwip_send(fd, dataptr, size, flags);
236 if (res < 0)
237 {
238 return -errno;
239 }
240 return res;
241}
242
243int __ps2ipeeSendtoHelper(void *userdata, const void *dataptr, size_t size, int flags, const struct sockaddr *to, socklen_t tolen)
244{
245 int fd, res;
246
247 fd = __ps2ipeeGetFdHelper(userdata);
248
249 if (fd < 0)
250 {
251 return fd;
252 }
253
254 res = lwip_sendto(fd, dataptr, size, flags, to, tolen);
255 if (res < 0)
256 {
257 return -errno;
258 }
259 return res;
260}
261
262int __ps2ipeeSendmsgHelper(void *userdata, const struct msghdr *msg, int flags) {
263 // TODO
264 return -1;
265}
266
267int __ps2ipeeIoctlHelper(void *userdata, int cmd, void *argp)
268{
269 int fd, res;
270
271 fd = __ps2ipeeGetFdHelper(userdata);
272
273 if (fd < 0)
274 {
275 return fd;
276 }
277
278 res = lwip_ioctl(fd, cmd, argp);
279 if (res < 0)
280 {
281 return -errno;
282 }
283 return res;
284}
285
286int __ps2ipeeGetsocknameHelper(void *userdata, struct sockaddr* name, socklen_t* namelen)
287{
288 int fd, res;
289
290 fd = __ps2ipeeGetFdHelper(userdata);
291
292 if (fd < 0)
293 {
294 return fd;
295 }
296
297 res = lwip_getsockname(fd, name, namelen);
298 if (res < 0)
299 {
300 return -errno;
301 }
302 return res;
303}
304
305int __ps2ipeeGetpeernameHelper(void *userdata, struct sockaddr *name, socklen_t *namelen)
306{
307 int fd, res;
308
309 fd = __ps2ipeeGetFdHelper(userdata);
310
311 if (fd < 0)
312 {
313 return fd;
314 }
315
316 res = lwip_getpeername(fd, name, namelen);
317 if (res < 0)
318 {
319 return -errno;
320 }
321 return res;
322}
323
324int __ps2ipeeGetsockoptHelper(void *userdata, int level, int optname, void* optval, socklen_t* optlen)
325{
326 int fd, res;
327
328 fd = __ps2ipeeGetFdHelper(userdata);
329
330 if (fd < 0)
331 {
332 return fd;
333 }
334
335 res = lwip_getsockopt(fd, level, optname, optval, optlen);
336 if (res < 0)
337 {
338 return -errno;
339 }
340 return res;
341}
342
343int __ps2ipeeSetsockoptHelper(void *userdata, int level, int optname, const void *optval, socklen_t optlen)
344{
345 int fd, res;
346
347 fd = __ps2ipeeGetFdHelper(userdata);
348
349 if (fd < 0)
350 {
351 return fd;
352 }
353
354 res = lwip_setsockopt(fd, level, optname, optval, optlen);
355 if (res < 0)
356 {
357 return -errno;
358 }
359 return res;
360}
361
362int __ps2ipeeShutdownHelper(void *userdata, int how)
363{
364 int fd, res;
365
366 fd = __ps2ipeeGetFdHelper(userdata);
367
368 if (fd < 0)
369 {
370 return fd;
371 }
372
373 res = lwip_shutdown(fd, how);
374 if (res < 0)
375 {
376 return -errno;
377 }
378 return res;
379}
380
381int __ps2ipeeReadHelper(void *userdata, void *mem, int len)
382{
383 int fd, res;
384
385 fd = __ps2ipeeGetFdHelper(userdata);
386
387 if (fd < 0)
388 {
389 return fd;
390 }
391
392 res = lwip_read(fd, mem, len);
393 if (res < 0)
394 {
395 return -errno;
396 }
397 return res;
398}
399
400int __ps2ipeeWriteHelper(void *userdata, const void *mem, int len)
401{
402 int fd, res;
403
404 fd = __ps2ipeeGetFdHelper(userdata);
405
406 if (fd < 0)
407 {
408 return fd;
409 }
410
411 res = lwip_write(fd, mem, len);
412 if (res < 0)
413 {
414 return -errno;
415 }
416 return res;
417}
418
419struct hostent *ps2ip_gethostbyaddr(const void *addr, int len, int type) {
420 // TODO
421 return NULL;
422}
423
424
425void __ps2ipeeOpsInitializeImpl(void)
426{
427 memset(&__ps2ipee_fdman_socket_ops, 0, sizeof(__ps2ipee_fdman_socket_ops));
428 __ps2ipee_fdman_socket_ops.setconfig = ps2ip_setconfig;
429 __ps2ipee_fdman_socket_ops.getconfig = ps2ip_getconfig;
430 __ps2ipee_fdman_socket_ops.dns_setserver = dns_setserver;
431 __ps2ipee_fdman_socket_ops.dns_getserver = dns_getserver;
432 __ps2ipee_fdman_socket_ops.socket = __ps2ipeeSocketHelper;
433 __ps2ipee_fdman_socket_ops.select = lwip_select;
434 __ps2ipee_fdman_socket_ops.gethostbyaddr = ps2ip_gethostbyaddr;
435 __ps2ipee_fdman_socket_ops.gethostbyname = lwip_gethostbyname;
436 __ps2ipee_fdman_socket_ops.gethostbyname_r = lwip_gethostbyname_r;
437 __ps2ipee_fdman_socket_ops.freeaddrinfo = lwip_freeaddrinfo;
438 __ps2ipee_fdman_socket_ops.getaddrinfo = lwip_getaddrinfo;
439
440 memset(&__ps2ipee_fdman_inet_ops, 0, sizeof(__ps2ipee_fdman_inet_ops));
441 __ps2ipee_fdman_inet_ops.inet_addr = __ps2ipeeInetAddrHelper;
442 __ps2ipee_fdman_inet_ops.inet_ntoa = ip4addr_ntoa;
443 __ps2ipee_fdman_inet_ops.inet_ntoa_r = ip4addr_ntoa_r;
444 __ps2ipee_fdman_inet_ops.inet_aton = ip4addr_aton;
445
446 memset(&__ps2ipee_fdman_ops_socket, 0, sizeof(__ps2ipee_fdman_ops_socket));
447 __ps2ipee_fdman_ops_socket.getfd = __ps2ipeeGetFdHelper;
448 __ps2ipee_fdman_ops_socket.fcntl_f_setfl = __ps2ipeeFcntlfsetflHelper;
449
450 __ps2ipee_fdman_ops_socket.accept = __ps2ipeeAcceptHelper;
451 __ps2ipee_fdman_ops_socket.bind = __ps2ipeeBindHelper;
452 __ps2ipee_fdman_ops_socket.close = __ps2ipeeCloseHelper;
453 __ps2ipee_fdman_ops_socket.connect = __ps2ipeeConnectHelper;
454 __ps2ipee_fdman_ops_socket.listen = __ps2ipeeListenHelper;
455 __ps2ipee_fdman_ops_socket.recv = __ps2ipeeRecvHelper;
456 __ps2ipee_fdman_ops_socket.recvfrom = __ps2ipeeRecvfromHelper;
457 __ps2ipee_fdman_ops_socket.recvmsg = __ps2ipeeRecvmsgHelper;
458 __ps2ipee_fdman_ops_socket.send = __ps2ipeeSendHelper;
459 __ps2ipee_fdman_ops_socket.sendto = __ps2ipeeSendtoHelper;
460 __ps2ipee_fdman_ops_socket.sendmsg = __ps2ipeeSendmsgHelper;
461 __ps2ipee_fdman_ops_socket.ioctl = __ps2ipeeIoctlHelper;
462 __ps2ipee_fdman_ops_socket.getsockname = __ps2ipeeGetsocknameHelper;
463 __ps2ipee_fdman_ops_socket.getpeername = __ps2ipeeGetpeernameHelper;
464 __ps2ipee_fdman_ops_socket.getsockopt = __ps2ipeeGetsockoptHelper;
465 __ps2ipee_fdman_ops_socket.setsockopt = __ps2ipeeSetsockoptHelper;
466 __ps2ipee_fdman_ops_socket.shutdown = __ps2ipeeShutdownHelper;
467 __ps2ipee_fdman_ops_socket.read = __ps2ipeeReadHelper;
468 __ps2ipee_fdman_ops_socket.write = __ps2ipeeWriteHelper;
469}
470
471/* Backup pointer functions to restore after exit ps2ipee */
472static _libcglue_fdman_socket_ops_t *_backup_libcglue_fdman_socket_ops;
473static _libcglue_fdman_inet_ops_t *_backup_libcglue_fdman_inet_ops;
474
475void _ps2sdk_ps2ipee_init(void)
476{
477 _backup_libcglue_fdman_socket_ops = _libcglue_fdman_socket_ops;
478 _libcglue_fdman_socket_ops = &__ps2ipee_fdman_socket_ops;
479 /* Without this, libcglue's inet_addr/inet_ntoa/inet_aton fall into the
480 * ops==NULL branch and silently return 0/NULL — so inet_addr("1.2.3.4")
481 * gives 0.0.0.0, and any outbound packet using a string-resolved IP
482 * (UDP sendto, TCP connect by IP literal) ends up addressed to 0.0.0.0,
483 * which lwIP routes to the broadcast MAC. The IOP-side path doesn't hit
484 * this because its init wires libcglue ops via a different code path. */
485 _backup_libcglue_fdman_inet_ops = _libcglue_fdman_inet_ops;
486 _libcglue_fdman_inet_ops = &__ps2ipee_fdman_inet_ops;
487}
488
489void _ps2sdk_ps2ipee_deinit(void)
490{
491 _libcglue_fdman_socket_ops = _backup_libcglue_fdman_socket_ops;
492 _libcglue_fdman_inet_ops = _backup_libcglue_fdman_inet_ops;
493}
ENFILE
#define ENFILE
Definition errno.h:74
ip4addr_ntoa
char * ip4addr_ntoa(const ip4_addr_t *addr)
__attribute__
Definition gif_registers.h:40
mem
Definition mem.c:336