diff options
author | E. Westbrook <github@westbrook.io> | 2019-02-27 21:02:24 -0700 |
---|---|---|
committer | E. Westbrook <github@westbrook.io> | 2019-03-10 00:04:20 -0700 |
commit | 8b2dcdcf7d98194e9d501c0a76a048606761983f (patch) | |
tree | 4da7e822f306d33cceb7b0e398cc7c7403f3423d /src/usocket.c | |
parent | 4e363330a3b9e6ba082869f87820690e501f0a2d (diff) | |
download | luasocket-8b2dcdcf7d98194e9d501c0a76a048606761983f.tar.gz luasocket-8b2dcdcf7d98194e9d501c0a76a048606761983f.tar.bz2 luasocket-8b2dcdcf7d98194e9d501c0a76a048606761983f.zip |
usocket: pragma visibility
Diffstat (limited to 'src/usocket.c')
-rw-r--r-- | src/usocket.c | 53 |
1 files changed, 26 insertions, 27 deletions
diff --git a/src/usocket.c b/src/usocket.c index aee876d..acfe186 100644 --- a/src/usocket.c +++ b/src/usocket.c | |||
@@ -23,7 +23,7 @@ | |||
23 | #define WAITFD_R POLLIN | 23 | #define WAITFD_R POLLIN |
24 | #define WAITFD_W POLLOUT | 24 | #define WAITFD_W POLLOUT |
25 | #define WAITFD_C (POLLIN|POLLOUT) | 25 | #define WAITFD_C (POLLIN|POLLOUT) |
26 | LUASOCKET_PRIVATE int socket_waitfd(p_socket ps, int sw, p_timeout tm) { | 26 | int socket_waitfd(p_socket ps, int sw, p_timeout tm) { |
27 | int ret; | 27 | int ret; |
28 | struct pollfd pfd; | 28 | struct pollfd pfd; |
29 | pfd.fd = *ps; | 29 | pfd.fd = *ps; |
@@ -45,7 +45,7 @@ LUASOCKET_PRIVATE int socket_waitfd(p_socket ps, int sw, p_timeout tm) { | |||
45 | #define WAITFD_W 2 | 45 | #define WAITFD_W 2 |
46 | #define WAITFD_C (WAITFD_R|WAITFD_W) | 46 | #define WAITFD_C (WAITFD_R|WAITFD_W) |
47 | 47 | ||
48 | LUASOCKET_PRIVATE int socket_waitfd(p_socket ps, int sw, p_timeout tm) { | 48 | int socket_waitfd(p_socket ps, int sw, p_timeout tm) { |
49 | int ret; | 49 | int ret; |
50 | fd_set rfds, wfds, *rp, *wp; | 50 | fd_set rfds, wfds, *rp, *wp; |
51 | struct timeval tv, *tp; | 51 | struct timeval tv, *tp; |
@@ -77,7 +77,7 @@ LUASOCKET_PRIVATE int socket_waitfd(p_socket ps, int sw, p_timeout tm) { | |||
77 | /*-------------------------------------------------------------------------*\ | 77 | /*-------------------------------------------------------------------------*\ |
78 | * Initializes module | 78 | * Initializes module |
79 | \*-------------------------------------------------------------------------*/ | 79 | \*-------------------------------------------------------------------------*/ |
80 | LUASOCKET_PRIVATE int socket_open(void) { | 80 | int socket_open(void) { |
81 | /* installs a handler to ignore sigpipe or it will crash us */ | 81 | /* installs a handler to ignore sigpipe or it will crash us */ |
82 | signal(SIGPIPE, SIG_IGN); | 82 | signal(SIGPIPE, SIG_IGN); |
83 | return 1; | 83 | return 1; |
@@ -86,14 +86,14 @@ LUASOCKET_PRIVATE int socket_open(void) { | |||
86 | /*-------------------------------------------------------------------------*\ | 86 | /*-------------------------------------------------------------------------*\ |
87 | * Close module | 87 | * Close module |
88 | \*-------------------------------------------------------------------------*/ | 88 | \*-------------------------------------------------------------------------*/ |
89 | LUASOCKET_PRIVATE int socket_close(void) { | 89 | int socket_close(void) { |
90 | return 1; | 90 | return 1; |
91 | } | 91 | } |
92 | 92 | ||
93 | /*-------------------------------------------------------------------------*\ | 93 | /*-------------------------------------------------------------------------*\ |
94 | * Close and inutilize socket | 94 | * Close and inutilize socket |
95 | \*-------------------------------------------------------------------------*/ | 95 | \*-------------------------------------------------------------------------*/ |
96 | LUASOCKET_PRIVATE void socket_destroy(p_socket ps) { | 96 | void socket_destroy(p_socket ps) { |
97 | if (*ps != SOCKET_INVALID) { | 97 | if (*ps != SOCKET_INVALID) { |
98 | close(*ps); | 98 | close(*ps); |
99 | *ps = SOCKET_INVALID; | 99 | *ps = SOCKET_INVALID; |
@@ -103,7 +103,7 @@ LUASOCKET_PRIVATE void socket_destroy(p_socket ps) { | |||
103 | /*-------------------------------------------------------------------------*\ | 103 | /*-------------------------------------------------------------------------*\ |
104 | * Select with timeout control | 104 | * Select with timeout control |
105 | \*-------------------------------------------------------------------------*/ | 105 | \*-------------------------------------------------------------------------*/ |
106 | LUASOCKET_PRIVATE int socket_select(t_socket n, fd_set *rfds, fd_set *wfds, fd_set *efds, | 106 | int socket_select(t_socket n, fd_set *rfds, fd_set *wfds, fd_set *efds, |
107 | p_timeout tm) { | 107 | p_timeout tm) { |
108 | int ret; | 108 | int ret; |
109 | do { | 109 | do { |
@@ -120,7 +120,7 @@ LUASOCKET_PRIVATE int socket_select(t_socket n, fd_set *rfds, fd_set *wfds, fd_s | |||
120 | /*-------------------------------------------------------------------------*\ | 120 | /*-------------------------------------------------------------------------*\ |
121 | * Creates and sets up a socket | 121 | * Creates and sets up a socket |
122 | \*-------------------------------------------------------------------------*/ | 122 | \*-------------------------------------------------------------------------*/ |
123 | LUASOCKET_PRIVATE int socket_create(p_socket ps, int domain, int type, int protocol) { | 123 | int socket_create(p_socket ps, int domain, int type, int protocol) { |
124 | *ps = socket(domain, type, protocol); | 124 | *ps = socket(domain, type, protocol); |
125 | if (*ps != SOCKET_INVALID) return IO_DONE; | 125 | if (*ps != SOCKET_INVALID) return IO_DONE; |
126 | else return errno; | 126 | else return errno; |
@@ -129,7 +129,7 @@ LUASOCKET_PRIVATE int socket_create(p_socket ps, int domain, int type, int proto | |||
129 | /*-------------------------------------------------------------------------*\ | 129 | /*-------------------------------------------------------------------------*\ |
130 | * Binds or returns error message | 130 | * Binds or returns error message |
131 | \*-------------------------------------------------------------------------*/ | 131 | \*-------------------------------------------------------------------------*/ |
132 | LUASOCKET_PRIVATE int socket_bind(p_socket ps, SA *addr, socklen_t len) { | 132 | int socket_bind(p_socket ps, SA *addr, socklen_t len) { |
133 | int err = IO_DONE; | 133 | int err = IO_DONE; |
134 | socket_setblocking(ps); | 134 | socket_setblocking(ps); |
135 | if (bind(*ps, addr, len) < 0) err = errno; | 135 | if (bind(*ps, addr, len) < 0) err = errno; |
@@ -140,7 +140,7 @@ LUASOCKET_PRIVATE int socket_bind(p_socket ps, SA *addr, socklen_t len) { | |||
140 | /*-------------------------------------------------------------------------*\ | 140 | /*-------------------------------------------------------------------------*\ |
141 | * | 141 | * |
142 | \*-------------------------------------------------------------------------*/ | 142 | \*-------------------------------------------------------------------------*/ |
143 | LUASOCKET_PRIVATE int socket_listen(p_socket ps, int backlog) { | 143 | int socket_listen(p_socket ps, int backlog) { |
144 | int err = IO_DONE; | 144 | int err = IO_DONE; |
145 | if (listen(*ps, backlog)) err = errno; | 145 | if (listen(*ps, backlog)) err = errno; |
146 | return err; | 146 | return err; |
@@ -149,14 +149,14 @@ LUASOCKET_PRIVATE int socket_listen(p_socket ps, int backlog) { | |||
149 | /*-------------------------------------------------------------------------*\ | 149 | /*-------------------------------------------------------------------------*\ |
150 | * | 150 | * |
151 | \*-------------------------------------------------------------------------*/ | 151 | \*-------------------------------------------------------------------------*/ |
152 | LUASOCKET_PRIVATE void socket_shutdown(p_socket ps, int how) { | 152 | void socket_shutdown(p_socket ps, int how) { |
153 | shutdown(*ps, how); | 153 | shutdown(*ps, how); |
154 | } | 154 | } |
155 | 155 | ||
156 | /*-------------------------------------------------------------------------*\ | 156 | /*-------------------------------------------------------------------------*\ |
157 | * Connects or returns error message | 157 | * Connects or returns error message |
158 | \*-------------------------------------------------------------------------*/ | 158 | \*-------------------------------------------------------------------------*/ |
159 | LUASOCKET_PRIVATE int socket_connect(p_socket ps, SA *addr, socklen_t len, p_timeout tm) { | 159 | int socket_connect(p_socket ps, SA *addr, socklen_t len, p_timeout tm) { |
160 | int err; | 160 | int err; |
161 | /* avoid calling on closed sockets */ | 161 | /* avoid calling on closed sockets */ |
162 | if (*ps == SOCKET_INVALID) return IO_CLOSED; | 162 | if (*ps == SOCKET_INVALID) return IO_CLOSED; |
@@ -178,7 +178,7 @@ LUASOCKET_PRIVATE int socket_connect(p_socket ps, SA *addr, socklen_t len, p_tim | |||
178 | /*-------------------------------------------------------------------------*\ | 178 | /*-------------------------------------------------------------------------*\ |
179 | * Accept with timeout | 179 | * Accept with timeout |
180 | \*-------------------------------------------------------------------------*/ | 180 | \*-------------------------------------------------------------------------*/ |
181 | LUASOCKET_PRIVATE int socket_accept(p_socket ps, p_socket pa, SA *addr, socklen_t *len, p_timeout tm) { | 181 | int socket_accept(p_socket ps, p_socket pa, SA *addr, socklen_t *len, p_timeout tm) { |
182 | if (*ps == SOCKET_INVALID) return IO_CLOSED; | 182 | if (*ps == SOCKET_INVALID) return IO_CLOSED; |
183 | for ( ;; ) { | 183 | for ( ;; ) { |
184 | int err; | 184 | int err; |
@@ -195,7 +195,7 @@ LUASOCKET_PRIVATE int socket_accept(p_socket ps, p_socket pa, SA *addr, socklen_ | |||
195 | /*-------------------------------------------------------------------------*\ | 195 | /*-------------------------------------------------------------------------*\ |
196 | * Send with timeout | 196 | * Send with timeout |
197 | \*-------------------------------------------------------------------------*/ | 197 | \*-------------------------------------------------------------------------*/ |
198 | LUASOCKET_PRIVATE int socket_send(p_socket ps, const char *data, size_t count, | 198 | int socket_send(p_socket ps, const char *data, size_t count, |
199 | size_t *sent, p_timeout tm) | 199 | size_t *sent, p_timeout tm) |
200 | { | 200 | { |
201 | int err; | 201 | int err; |
@@ -229,7 +229,7 @@ LUASOCKET_PRIVATE int socket_send(p_socket ps, const char *data, size_t count, | |||
229 | /*-------------------------------------------------------------------------*\ | 229 | /*-------------------------------------------------------------------------*\ |
230 | * Sendto with timeout | 230 | * Sendto with timeout |
231 | \*-------------------------------------------------------------------------*/ | 231 | \*-------------------------------------------------------------------------*/ |
232 | LUASOCKET_PRIVATE int socket_sendto(p_socket ps, const char *data, size_t count, size_t *sent, | 232 | int socket_sendto(p_socket ps, const char *data, size_t count, size_t *sent, |
233 | SA *addr, socklen_t len, p_timeout tm) | 233 | SA *addr, socklen_t len, p_timeout tm) |
234 | { | 234 | { |
235 | int err; | 235 | int err; |
@@ -254,7 +254,7 @@ LUASOCKET_PRIVATE int socket_sendto(p_socket ps, const char *data, size_t count, | |||
254 | /*-------------------------------------------------------------------------*\ | 254 | /*-------------------------------------------------------------------------*\ |
255 | * Receive with timeout | 255 | * Receive with timeout |
256 | \*-------------------------------------------------------------------------*/ | 256 | \*-------------------------------------------------------------------------*/ |
257 | LUASOCKET_PRIVATE int socket_recv(p_socket ps, char *data, size_t count, size_t *got, p_timeout tm) { | 257 | int socket_recv(p_socket ps, char *data, size_t count, size_t *got, p_timeout tm) { |
258 | int err; | 258 | int err; |
259 | *got = 0; | 259 | *got = 0; |
260 | if (*ps == SOCKET_INVALID) return IO_CLOSED; | 260 | if (*ps == SOCKET_INVALID) return IO_CLOSED; |
@@ -276,7 +276,7 @@ LUASOCKET_PRIVATE int socket_recv(p_socket ps, char *data, size_t count, size_t | |||
276 | /*-------------------------------------------------------------------------*\ | 276 | /*-------------------------------------------------------------------------*\ |
277 | * Recvfrom with timeout | 277 | * Recvfrom with timeout |
278 | \*-------------------------------------------------------------------------*/ | 278 | \*-------------------------------------------------------------------------*/ |
279 | LUASOCKET_PRIVATE int socket_recvfrom(p_socket ps, char *data, size_t count, size_t *got, | 279 | int socket_recvfrom(p_socket ps, char *data, size_t count, size_t *got, |
280 | SA *addr, socklen_t *len, p_timeout tm) { | 280 | SA *addr, socklen_t *len, p_timeout tm) { |
281 | int err; | 281 | int err; |
282 | *got = 0; | 282 | *got = 0; |
@@ -304,7 +304,7 @@ LUASOCKET_PRIVATE int socket_recvfrom(p_socket ps, char *data, size_t count, siz | |||
304 | * with send/recv replaced with write/read. We can't just use write/read | 304 | * with send/recv replaced with write/read. We can't just use write/read |
305 | * in the socket version, because behaviour when size is zero is different. | 305 | * in the socket version, because behaviour when size is zero is different. |
306 | \*-------------------------------------------------------------------------*/ | 306 | \*-------------------------------------------------------------------------*/ |
307 | LUASOCKET_PRIVATE int socket_write(p_socket ps, const char *data, size_t count, | 307 | int socket_write(p_socket ps, const char *data, size_t count, |
308 | size_t *sent, p_timeout tm) | 308 | size_t *sent, p_timeout tm) |
309 | { | 309 | { |
310 | int err; | 310 | int err; |
@@ -339,7 +339,7 @@ LUASOCKET_PRIVATE int socket_write(p_socket ps, const char *data, size_t count, | |||
339 | * Read with timeout | 339 | * Read with timeout |
340 | * See note for socket_write | 340 | * See note for socket_write |
341 | \*-------------------------------------------------------------------------*/ | 341 | \*-------------------------------------------------------------------------*/ |
342 | LUASOCKET_PRIVATE int socket_read(p_socket ps, char *data, size_t count, size_t *got, p_timeout tm) { | 342 | int socket_read(p_socket ps, char *data, size_t count, size_t *got, p_timeout tm) { |
343 | int err; | 343 | int err; |
344 | *got = 0; | 344 | *got = 0; |
345 | if (*ps == SOCKET_INVALID) return IO_CLOSED; | 345 | if (*ps == SOCKET_INVALID) return IO_CLOSED; |
@@ -361,7 +361,7 @@ LUASOCKET_PRIVATE int socket_read(p_socket ps, char *data, size_t count, size_t | |||
361 | /*-------------------------------------------------------------------------*\ | 361 | /*-------------------------------------------------------------------------*\ |
362 | * Put socket into blocking mode | 362 | * Put socket into blocking mode |
363 | \*-------------------------------------------------------------------------*/ | 363 | \*-------------------------------------------------------------------------*/ |
364 | LUASOCKET_PRIVATE void socket_setblocking(p_socket ps) { | 364 | void socket_setblocking(p_socket ps) { |
365 | int flags = fcntl(*ps, F_GETFL, 0); | 365 | int flags = fcntl(*ps, F_GETFL, 0); |
366 | flags &= (~(O_NONBLOCK)); | 366 | flags &= (~(O_NONBLOCK)); |
367 | fcntl(*ps, F_SETFL, flags); | 367 | fcntl(*ps, F_SETFL, flags); |
@@ -370,7 +370,7 @@ LUASOCKET_PRIVATE void socket_setblocking(p_socket ps) { | |||
370 | /*-------------------------------------------------------------------------*\ | 370 | /*-------------------------------------------------------------------------*\ |
371 | * Put socket into non-blocking mode | 371 | * Put socket into non-blocking mode |
372 | \*-------------------------------------------------------------------------*/ | 372 | \*-------------------------------------------------------------------------*/ |
373 | LUASOCKET_PRIVATE void socket_setnonblocking(p_socket ps) { | 373 | void socket_setnonblocking(p_socket ps) { |
374 | int flags = fcntl(*ps, F_GETFL, 0); | 374 | int flags = fcntl(*ps, F_GETFL, 0); |
375 | flags |= O_NONBLOCK; | 375 | flags |= O_NONBLOCK; |
376 | fcntl(*ps, F_SETFL, flags); | 376 | fcntl(*ps, F_SETFL, flags); |
@@ -379,7 +379,7 @@ LUASOCKET_PRIVATE void socket_setnonblocking(p_socket ps) { | |||
379 | /*-------------------------------------------------------------------------*\ | 379 | /*-------------------------------------------------------------------------*\ |
380 | * DNS helpers | 380 | * DNS helpers |
381 | \*-------------------------------------------------------------------------*/ | 381 | \*-------------------------------------------------------------------------*/ |
382 | LUASOCKET_PRIVATE int socket_gethostbyaddr(const char *addr, socklen_t len, struct hostent **hp) { | 382 | int socket_gethostbyaddr(const char *addr, socklen_t len, struct hostent **hp) { |
383 | *hp = gethostbyaddr(addr, len, AF_INET); | 383 | *hp = gethostbyaddr(addr, len, AF_INET); |
384 | if (*hp) return IO_DONE; | 384 | if (*hp) return IO_DONE; |
385 | else if (h_errno) return h_errno; | 385 | else if (h_errno) return h_errno; |
@@ -387,7 +387,7 @@ LUASOCKET_PRIVATE int socket_gethostbyaddr(const char *addr, socklen_t len, stru | |||
387 | else return IO_UNKNOWN; | 387 | else return IO_UNKNOWN; |
388 | } | 388 | } |
389 | 389 | ||
390 | LUASOCKET_PRIVATE int socket_gethostbyname(const char *addr, struct hostent **hp) { | 390 | int socket_gethostbyname(const char *addr, struct hostent **hp) { |
391 | *hp = gethostbyname(addr); | 391 | *hp = gethostbyname(addr); |
392 | if (*hp) return IO_DONE; | 392 | if (*hp) return IO_DONE; |
393 | else if (h_errno) return h_errno; | 393 | else if (h_errno) return h_errno; |
@@ -399,7 +399,7 @@ LUASOCKET_PRIVATE int socket_gethostbyname(const char *addr, struct hostent **hp | |||
399 | * Error translation functions | 399 | * Error translation functions |
400 | * Make sure important error messages are standard | 400 | * Make sure important error messages are standard |
401 | \*-------------------------------------------------------------------------*/ | 401 | \*-------------------------------------------------------------------------*/ |
402 | LUASOCKET_PRIVATE const char *socket_hoststrerror(int err) { | 402 | const char *socket_hoststrerror(int err) { |
403 | if (err <= 0) return io_strerror(err); | 403 | if (err <= 0) return io_strerror(err); |
404 | switch (err) { | 404 | switch (err) { |
405 | case HOST_NOT_FOUND: return PIE_HOST_NOT_FOUND; | 405 | case HOST_NOT_FOUND: return PIE_HOST_NOT_FOUND; |
@@ -407,7 +407,7 @@ LUASOCKET_PRIVATE const char *socket_hoststrerror(int err) { | |||
407 | } | 407 | } |
408 | } | 408 | } |
409 | 409 | ||
410 | LUASOCKET_PRIVATE const char *socket_strerror(int err) { | 410 | const char *socket_strerror(int err) { |
411 | if (err <= 0) return io_strerror(err); | 411 | if (err <= 0) return io_strerror(err); |
412 | switch (err) { | 412 | switch (err) { |
413 | case EADDRINUSE: return PIE_ADDRINUSE; | 413 | case EADDRINUSE: return PIE_ADDRINUSE; |
@@ -423,12 +423,12 @@ LUASOCKET_PRIVATE const char *socket_strerror(int err) { | |||
423 | } | 423 | } |
424 | } | 424 | } |
425 | 425 | ||
426 | LUASOCKET_PRIVATE const char *socket_ioerror(p_socket ps, int err) { | 426 | const char *socket_ioerror(p_socket ps, int err) { |
427 | (void) ps; | 427 | (void) ps; |
428 | return socket_strerror(err); | 428 | return socket_strerror(err); |
429 | } | 429 | } |
430 | 430 | ||
431 | LUASOCKET_PRIVATE const char *socket_gaistrerror(int err) { | 431 | const char *socket_gaistrerror(int err) { |
432 | if (err == 0) return NULL; | 432 | if (err == 0) return NULL; |
433 | switch (err) { | 433 | switch (err) { |
434 | case EAI_AGAIN: return PIE_AGAIN; | 434 | case EAI_AGAIN: return PIE_AGAIN; |
@@ -452,4 +452,3 @@ LUASOCKET_PRIVATE const char *socket_gaistrerror(int err) { | |||
452 | default: return gai_strerror(err); | 452 | default: return gai_strerror(err); |
453 | } | 453 | } |
454 | } | 454 | } |
455 | |||