PageRenderTime 44ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 0ms

/sprx/libnet/socket.c

https://github.com/ser8210/PSL1GHT
C | 413 lines | 360 code | 53 blank | 0 comment | 44 complexity | e34b5334c056ceb07b7d54a5740d3bcd MD5 | raw file
  1. #include <psl1ght/lv2/net.h>
  2. #include <psl1ght/lv2/errno.h>
  3. #include <sys/socket.h>
  4. #include <sys/select.h>
  5. #include <netinet/in.h>
  6. #include <arpa/inet.h>
  7. #include <netdb.h>
  8. #include <stdio.h>
  9. #include <string.h>
  10. #define __LINUX_ERRNO_EXTENSIONS__
  11. #include <errno.h>
  12. int h_errno = 0;
  13. #define FD(socket) (socket & ~SOCKET_FD_MASK)
  14. void* __netMemory = NULL;
  15. #define LIBNET_INITIALIZED (__netMemory)
  16. const static int neterrno2errno[] = {
  17. [NET_EPERM] = EPERM,
  18. [NET_ENOENT] = ENOENT,
  19. [NET_ESRCH] = ESRCH,
  20. [NET_EINTR] = EINTR,
  21. [NET_EIO] = EIO,
  22. [NET_ENXIO] = ENXIO,
  23. [NET_E2BIG] = E2BIG,
  24. [NET_ENOEXEC] = ENOEXEC,
  25. [NET_EBADF] = EBADF,
  26. [NET_ECHILD] = ECHILD,
  27. [NET_EDEADLK] = EDEADLK,
  28. [NET_ENOMEM] = ENOMEM,
  29. [NET_EACCES] = EACCES,
  30. [NET_EFAULT] = EFAULT,
  31. [NET_ENOTBLK] = ENOTBLK,
  32. [NET_EBUSY] = EBUSY,
  33. [NET_EEXIST] = EEXIST,
  34. [NET_EXDEV] = EXDEV,
  35. [NET_ENODEV] = ENODEV,
  36. [NET_ENOTDIR] = ENOTDIR,
  37. [NET_EISDIR] = EISDIR,
  38. [NET_EINVAL] = EINVAL,
  39. [NET_ENFILE] = ENFILE,
  40. [NET_EMFILE] = EMFILE,
  41. [NET_ENOTTY] = ENOTTY,
  42. [NET_ETXTBSY] = ETXTBSY,
  43. [NET_EFBIG] = EFBIG,
  44. [NET_ENOSPC] = ENOSPC,
  45. [NET_ESPIPE] = ESPIPE,
  46. [NET_EROFS] = EROFS,
  47. [NET_EMLINK] = EMLINK,
  48. [NET_EPIPE] = EPIPE,
  49. [NET_EDOM] = EDOM,
  50. [NET_ERANGE] = ERANGE,
  51. [NET_EAGAIN] = EAGAIN,
  52. [NET_EWOULDBLOCK] = EWOULDBLOCK,
  53. [NET_EINPROGRESS] = EINPROGRESS,
  54. [NET_EALREADY] = EALREADY,
  55. [NET_ENOTSOCK] = ENOTSOCK,
  56. [NET_EDESTADDRREQ] = EDESTADDRREQ,
  57. [NET_EMSGSIZE] = EMSGSIZE,
  58. [NET_EPROTOTYPE] = EPROTOTYPE,
  59. [NET_ENOPROTOOPT] = ENOPROTOOPT,
  60. [NET_EPROTONOSUPPORT] = EPROTONOSUPPORT,
  61. [NET_ESOCKTNOSUPPORT] = ESOCKTNOSUPPORT,
  62. [NET_EOPNOTSUPP] = EOPNOTSUPP,
  63. [NET_EPFNOSUPPORT] = EPFNOSUPPORT,
  64. [NET_EAFNOSUPPORT] = EAFNOSUPPORT,
  65. [NET_EADDRINUSE] = EADDRINUSE,
  66. [NET_EADDRNOTAVAIL] = EADDRNOTAVAIL,
  67. [NET_ENETDOWN] = ENETDOWN,
  68. [NET_ENETUNREACH] = ENETUNREACH,
  69. [NET_ENETRESET] = ENETRESET,
  70. [NET_ECONNABORTED] = ECONNABORTED,
  71. [NET_ECONNRESET] = ECONNRESET,
  72. [NET_ENOBUFS] = ENOBUFS,
  73. [NET_EISCONN] = EISCONN,
  74. [NET_ENOTCONN] = ENOTCONN,
  75. [NET_ESHUTDOWN] = ESHUTDOWN,
  76. [NET_ETOOMANYREFS] = ETOOMANYREFS,
  77. [NET_ETIMEDOUT] = ETIMEDOUT,
  78. [NET_ECONNREFUSED] = ECONNREFUSED,
  79. [NET_ELOOP] = ELOOP,
  80. [NET_ENAMETOOLONG] = ENAMETOOLONG,
  81. [NET_EHOSTDOWN] = EHOSTDOWN,
  82. [NET_EHOSTUNREACH] = EHOSTUNREACH,
  83. [NET_ENOTEMPTY] = ENOTEMPTY,
  84. [NET_EPROCLIM] = EPROCLIM,
  85. [NET_EUSERS] = EUSERS,
  86. [NET_EDQUOT] = EDQUOT,
  87. [NET_ESTALE] = ESTALE,
  88. [NET_EREMOTE] = EREMOTE,
  89. [NET_EBADRPC] = ENOTSUP, // no match
  90. [NET_ERPCMISMATCH] = ENOTSUP, // no match
  91. [NET_EPROGUNAVAIL] = ENOTSUP, // no match
  92. [NET_EPROGMISMATCH] = ENOTSUP, // no match
  93. [NET_EPROCUNAVAIL] = ENOTSUP, // no match
  94. [NET_ENOLCK] = ENOLCK,
  95. [NET_ENOSYS] = ENOSYS,
  96. [NET_EFTYPE] = EFTYPE,
  97. [NET_EAUTH] = EPERM, // no match
  98. [NET_ENEEDAUTH] = EPERM, // no match
  99. [NET_EIDRM] = EIDRM,
  100. [NET_ENOMSG] = ENOMSG,
  101. [NET_EOVERFLOW] = EOVERFLOW,
  102. [NET_EILSEQ] = EILSEQ,
  103. [NET_ENOTSUP] = ENOTSUP,
  104. [NET_ECANCELED] = ECANCELED,
  105. [NET_EBADMSG] = EBADMSG,
  106. [NET_ENODATA] = ENODATA,
  107. [NET_ENOSR] = ENOSR,
  108. [NET_ENOSTR] = ENOSTR,
  109. [NET_ETIME] = ETIME
  110. };
  111. int netErrno(int ret)
  112. {
  113. if (!LIBNET_INITIALIZED)
  114. return lv2Errno(ret);
  115. if (ret >= 0)
  116. return ret;
  117. if (net_errno < sizeof(neterrno2errno) / sizeof(neterrno2errno[0]))
  118. errno = neterrno2errno[net_errno] ?: ENOTSUP;
  119. else
  120. errno = ENOTSUP;
  121. return -1;
  122. }
  123. int accept(int socket, struct sockaddr* address, socklen_t* address_len)
  124. {
  125. s32 ret;
  126. net_socklen_t len;
  127. net_socklen_t* lenp = (address && address_len) ? &len : NULL;
  128. if (LIBNET_INITIALIZED)
  129. ret = netAccept(FD(socket), address, lenp);
  130. else
  131. ret = lv2NetAccept(FD(socket), address, lenp);
  132. if (ret < 0)
  133. return netErrno(ret);
  134. if (lenp)
  135. *address_len = len;
  136. return ret | SOCKET_FD_MASK;
  137. }
  138. int bind(int socket, const struct sockaddr* address, socklen_t address_len)
  139. {
  140. s32 ret;
  141. if (LIBNET_INITIALIZED)
  142. ret = netBind(FD(socket), address, (net_socklen_t)address_len);
  143. else
  144. ret = lv2NetBind(FD(socket), address, (net_socklen_t)address_len);
  145. return netErrno(ret);
  146. }
  147. int connect(int socket, const struct sockaddr* address, socklen_t address_len)
  148. {
  149. s32 ret;
  150. if (LIBNET_INITIALIZED)
  151. ret = netConnect(FD(socket), address, (net_socklen_t)address_len);
  152. else
  153. ret = lv2NetConnect(FD(socket), address, (net_socklen_t)address_len);
  154. return netErrno(ret);
  155. }
  156. int listen(int socket, int backlog)
  157. {
  158. s32 ret;
  159. if (LIBNET_INITIALIZED)
  160. ret = netListen(FD(socket), backlog);
  161. else
  162. ret = lv2NetListen(FD(socket), backlog);
  163. return netErrno(ret);
  164. }
  165. int socket(int domain, int type, int protocol)
  166. {
  167. s32 ret;
  168. if (LIBNET_INITIALIZED)
  169. ret = netSocket(domain, type, protocol);
  170. else
  171. ret = lv2NetSocket(domain, type, protocol);
  172. if (ret < 0)
  173. return netErrno(ret);
  174. return ret | SOCKET_FD_MASK;
  175. }
  176. ssize_t send(int socket, const void* message, size_t length, int flags)
  177. {
  178. s32 ret;
  179. if (LIBNET_INITIALIZED)
  180. ret = netSend(FD(socket), message, length, flags);
  181. else
  182. return sendto(socket, message, length, flags, NULL, 0);
  183. return netErrno(ret);
  184. }
  185. ssize_t sendto(int socket, const void* message, size_t length, int flags, const struct sockaddr* dest_addr, socklen_t dest_len)
  186. {
  187. s32 ret;
  188. if (LIBNET_INITIALIZED)
  189. ret = netSendTo(FD(socket), message, length, flags, dest_addr, (net_socklen_t)dest_len);
  190. else
  191. ret = lv2NetSendTo(FD(socket), message, length, flags, dest_addr, (net_socklen_t)dest_len);
  192. return netErrno(ret);
  193. }
  194. ssize_t recv(int s, void *buf, size_t len, int flags)
  195. {
  196. s32 ret;
  197. if (LIBNET_INITIALIZED)
  198. ret = netRecv(FD(s),buf,len,flags);
  199. else
  200. return recvfrom(s, buf, len, flags, NULL, NULL);
  201. return netErrno(ret);
  202. }
  203. ssize_t recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr* from, socklen_t* fromlen)
  204. {
  205. s32 ret;
  206. net_socklen_t socklen;
  207. net_socklen_t* socklenp = (from && fromlen) ? &socklen : NULL;
  208. if (LIBNET_INITIALIZED)
  209. ret = netRecvFrom(FD(s), buf, len, flags, from, socklenp);
  210. else
  211. ret = lv2NetRecvFrom(FD(s), buf, len, flags, from, socklenp);
  212. if (ret < 0)
  213. return netErrno(ret);
  214. if (socklenp)
  215. *fromlen = socklen;
  216. return ret;
  217. }
  218. int shutdown(int socket, int how)
  219. {
  220. s32 ret;
  221. if (LIBNET_INITIALIZED)
  222. ret = netShutdown(FD(socket), how);
  223. else
  224. ret = lv2NetShutdown(FD(socket), how);
  225. return netErrno(ret);
  226. }
  227. int closesocket(int socket)
  228. {
  229. s32 ret;
  230. if (LIBNET_INITIALIZED)
  231. ret = netClose(FD(socket));
  232. else
  233. ret = lv2NetClose(FD(socket));
  234. return netErrno(ret);
  235. }
  236. int select(int nfds, fd_set* readfds, fd_set* writefds, fd_set* errorfds, struct timeval_32* timeout)
  237. {
  238. s32 ret;
  239. if (LIBNET_INITIALIZED){
  240. ret = netSelect(nfds, readfds, writefds, errorfds, timeout);
  241. printf("netSelect(%d) = %08X\n", nfds, ret);
  242. }
  243. else
  244. ret = lv2NetSelect(nfds, readfds, writefds, errorfds, timeout);
  245. return netErrno(ret);
  246. }
  247. int poll(struct pollfd fds[], nfds_t nfds, int timeout)
  248. {
  249. int i, r;
  250. if (!LIBNET_INITIALIZED) {
  251. errno = ENOSYS;
  252. return -1;
  253. }
  254. for (i = 0; i < nfds; i++)
  255. fds[i].fd &= ~SOCKET_FD_MASK;
  256. r = netErrno(netPoll(fds, nfds, timeout));
  257. for (i = 0; i < nfds; i++)
  258. fds[i].fd |= SOCKET_FD_MASK;
  259. return r;
  260. }
  261. int getsockname(int socket, struct sockaddr* address, socklen_t* address_len)
  262. {
  263. s32 ret;
  264. net_socklen_t len;
  265. net_socklen_t* lenp = (address && address_len) ? &len : NULL;
  266. if (LIBNET_INITIALIZED)
  267. ret = netGetSockName(FD(socket), address, lenp);
  268. else
  269. ret = lv2NetGetSockName(FD(socket), address, lenp);
  270. if (ret < 0)
  271. return netErrno(ret);
  272. if (lenp)
  273. *address_len = len;
  274. return ret;
  275. }
  276. int getpeername(int socket, struct sockaddr* address, socklen_t* address_len)
  277. {
  278. s32 ret;
  279. net_socklen_t len;
  280. net_socklen_t* lenp = (address && address_len) ? &len : NULL;
  281. if (LIBNET_INITIALIZED)
  282. ret = netGetPeerName(FD(socket), address, lenp);
  283. else
  284. ret = lv2NetGetPeerName(FD(socket), address, lenp);
  285. if (ret < 0)
  286. return netErrno(ret);
  287. if (lenp)
  288. *address_len = len;
  289. return ret;
  290. }
  291. #define MAX_HOST_NAMES 0x20
  292. static struct hostent host;
  293. static char* hostaliases[MAX_HOST_NAMES];
  294. static char* hostaddrlist[MAX_HOST_NAMES];
  295. static struct hostent* copyhost(struct net_hostent* nethost)
  296. {
  297. if (!nethost)
  298. return NULL;
  299. memset(&host, 0, sizeof(host));
  300. host.h_name = (char*)(u64)nethost->h_name;
  301. host.h_addrtype = nethost->h_addrtype;
  302. host.h_length = nethost->h_length;
  303. host.h_aliases = hostaliases;
  304. host.h_addr_list = hostaddrlist;
  305. lv2_void* netaddrlist = (lv2_void*)(u64)nethost->h_addr_list;
  306. lv2_void* netaliases = (lv2_void*)(u64)nethost->h_aliases;
  307. for (int i = 0; i < MAX_HOST_NAMES; i++) {
  308. host.h_addr_list[i] = (char*)(u64)netaddrlist[i];
  309. if (!netaddrlist[i])
  310. break;
  311. }
  312. for (int i = 0; i < MAX_HOST_NAMES; i++) {
  313. host.h_aliases[i] = (char*)(u64)netaliases[i];
  314. if (!netaliases[i])
  315. break;
  316. }
  317. return &host;
  318. }
  319. struct hostent* gethostbyaddr(const char* addr, socklen_t len, int type)
  320. {
  321. if (!LIBNET_INITIALIZED) {
  322. errno = ENOSYS;
  323. h_errno = TRY_AGAIN;
  324. return NULL;
  325. }
  326. struct net_hostent* ret = netGetHostByAddr(addr, (net_socklen_t)len, type);
  327. if (!ret)
  328. h_errno = net_h_errno;
  329. return copyhost(ret);
  330. }
  331. struct hostent* gethostbyname(const char* name)
  332. {
  333. if (!LIBNET_INITIALIZED) {
  334. errno = ENOSYS;
  335. h_errno = TRY_AGAIN;
  336. return NULL;
  337. }
  338. struct net_hostent* ret = netGetHostByName(name);
  339. if (!ret)
  340. h_errno = net_h_errno;
  341. return copyhost(ret);
  342. }
  343. int getsockopt(int socket, int level, int option_name, void* option_value, socklen_t* option_len)
  344. {
  345. if (!LIBNET_INITIALIZED) {
  346. errno = ENOSYS;
  347. h_errno = TRY_AGAIN;
  348. return -1;
  349. }
  350. return netErrno(netGetSockOpt(FD(socket), level, option_name, option_value, option_len));
  351. }
  352. int setsockopt(int socket, int level, int option_name, const void* option_value, socklen_t option_len)
  353. {
  354. if (!LIBNET_INITIALIZED) {
  355. errno = ENOSYS;
  356. h_errno = TRY_AGAIN;
  357. return -1;
  358. }
  359. return netErrno(netSetSockOpt(FD(socket), level, option_name, option_value, option_len));
  360. }