1 /******************************************************************************
2 *
3 * Copyright (C) 2014 Google, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 #define LOG_TAG "bt_osi_socket"
20
21 #include <asm/ioctls.h>
22 #include <assert.h>
23 #include <errno.h>
24 #include <netinet/in.h>
25 #include <string.h>
26 #include <sys/ioctl.h>
27 #include <sys/socket.h>
28 #include <sys/types.h>
29 #include <unistd.h>
30
31 #include "osi/include/allocator.h"
32 #include "osi/include/osi.h"
33 #include "osi/include/log.h"
34 #include "osi/include/reactor.h"
35 #include "osi/include/socket.h"
36
37 // The IPv4 loopback address: 127.0.0.1
38 static const in_addr_t LOCALHOST_ = 0x7f000001;
39
40 struct socket_t {
41 int fd;
42 reactor_object_t *reactor_object;
43 socket_cb read_ready;
44 socket_cb write_ready;
45 void *context; // Not owned, do not free.
46 };
47
48 static void internal_read_ready(void *context);
49 static void internal_write_ready(void *context);
50
socket_new(void)51 socket_t *socket_new(void) {
52 socket_t *ret = (socket_t *)osi_calloc(sizeof(socket_t));
53 if (!ret) {
54 LOG_ERROR("%s unable to allocate memory for socket.", __func__);
55 goto error;
56 }
57
58 ret->fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
59 if (ret->fd == INVALID_FD) {
60 LOG_ERROR("%s unable to create socket: %s", __func__, strerror(errno));
61 goto error;
62 }
63
64 int enable = 1;
65 if (setsockopt(ret->fd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable)) == -1) {
66 LOG_ERROR("%s unable to set SO_REUSEADDR: %s", __func__, strerror(errno));
67 goto error;
68 }
69
70 return ret;
71
72 error:;
73 if (ret)
74 close(ret->fd);
75 osi_free(ret);
76 return NULL;
77 }
78
socket_new_from_fd(int fd)79 socket_t *socket_new_from_fd(int fd) {
80 assert(fd != INVALID_FD);
81
82 socket_t *ret = (socket_t *)osi_calloc(sizeof(socket_t));
83 if (!ret) {
84 LOG_ERROR("%s unable to allocate memory for socket.", __func__);
85 return NULL;
86 }
87
88 ret->fd = fd;
89 return ret;
90 }
91
socket_free(socket_t * socket)92 void socket_free(socket_t *socket) {
93 if (!socket)
94 return;
95
96 socket_unregister(socket);
97 close(socket->fd);
98 osi_free(socket);
99 }
100
socket_listen(const socket_t * socket,port_t port)101 bool socket_listen(const socket_t *socket, port_t port) {
102 assert(socket != NULL);
103
104 struct sockaddr_in addr;
105 addr.sin_family = AF_INET;
106 addr.sin_addr.s_addr = htonl(LOCALHOST_);
107 addr.sin_port = htons(port);
108 if (bind(socket->fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
109 LOG_ERROR("%s unable to bind socket to port %u: %s", __func__, port, strerror(errno));
110 return false;
111 }
112
113 if (listen(socket->fd, 10) == -1) {
114 LOG_ERROR("%s unable to listen on port %u: %s", __func__, port, strerror(errno));
115 return false;
116 }
117
118 return true;
119 }
120
socket_accept(const socket_t * socket)121 socket_t *socket_accept(const socket_t *socket) {
122 assert(socket != NULL);
123
124 int fd = accept(socket->fd, NULL, NULL);
125 if (fd == INVALID_FD) {
126 LOG_ERROR("%s unable to accept socket: %s", __func__, strerror(errno));
127 return NULL;
128 }
129
130 socket_t *ret = (socket_t *)osi_calloc(sizeof(socket_t));
131 if (!ret) {
132 close(fd);
133 LOG_ERROR("%s unable to allocate memory for socket.", __func__);
134 return NULL;
135 }
136
137 ret->fd = fd;
138 return ret;
139 }
140
socket_read(const socket_t * socket,void * buf,size_t count)141 ssize_t socket_read(const socket_t *socket, void *buf, size_t count) {
142 assert(socket != NULL);
143 assert(buf != NULL);
144
145 return recv(socket->fd, buf, count, MSG_DONTWAIT);
146 }
147
socket_write(const socket_t * socket,const void * buf,size_t count)148 ssize_t socket_write(const socket_t *socket, const void *buf, size_t count) {
149 assert(socket != NULL);
150 assert(buf != NULL);
151
152 return send(socket->fd, buf, count, MSG_DONTWAIT);
153 }
154
socket_write_and_transfer_fd(const socket_t * socket,const void * buf,size_t count,int fd)155 ssize_t socket_write_and_transfer_fd(const socket_t *socket, const void *buf, size_t count, int fd) {
156 assert(socket != NULL);
157 assert(buf != NULL);
158
159 if (fd == INVALID_FD)
160 return socket_write(socket, buf, count);
161
162 struct msghdr msg;
163 struct iovec iov;
164 char control_buf[CMSG_SPACE(sizeof(int))];
165
166 iov.iov_base = (void *)buf;
167 iov.iov_len = count;
168
169 msg.msg_iov = &iov;
170 msg.msg_iovlen = 1;
171 msg.msg_control = control_buf;
172 msg.msg_controllen = sizeof(control_buf);
173 msg.msg_name = NULL;
174 msg.msg_namelen = 0;
175
176 struct cmsghdr *header = CMSG_FIRSTHDR(&msg);
177 header->cmsg_level = SOL_SOCKET;
178 header->cmsg_type = SCM_RIGHTS;
179 header->cmsg_len = CMSG_LEN(sizeof(int));
180 *(int *)CMSG_DATA(header) = fd;
181
182 ssize_t ret = sendmsg(socket->fd, &msg, MSG_DONTWAIT);
183 close(fd);
184 return ret;
185 }
186
socket_bytes_available(const socket_t * socket)187 ssize_t socket_bytes_available(const socket_t *socket) {
188 assert(socket != NULL);
189
190 int size = 0;
191 if (ioctl(socket->fd, FIONREAD, &size) == -1)
192 return -1;
193 return size;
194 }
195
socket_register(socket_t * socket,reactor_t * reactor,void * context,socket_cb read_cb,socket_cb write_cb)196 void socket_register(socket_t *socket, reactor_t *reactor, void *context, socket_cb read_cb, socket_cb write_cb) {
197 assert(socket != NULL);
198
199 // Make sure the socket isn't currently registered.
200 socket_unregister(socket);
201
202 socket->read_ready = read_cb;
203 socket->write_ready = write_cb;
204 socket->context = context;
205
206 void (*read_fn)(void *) = (read_cb != NULL) ? internal_read_ready : NULL;
207 void (*write_fn)(void *) = (write_cb != NULL) ? internal_write_ready : NULL;
208
209 socket->reactor_object = reactor_register(reactor, socket->fd, socket, read_fn, write_fn);
210 }
211
socket_unregister(socket_t * socket)212 void socket_unregister(socket_t *socket) {
213 assert(socket != NULL);
214
215 if (socket->reactor_object)
216 reactor_unregister(socket->reactor_object);
217 socket->reactor_object = NULL;
218 }
219
internal_read_ready(void * context)220 static void internal_read_ready(void *context) {
221 assert(context != NULL);
222
223 socket_t *socket = (void *)context;
224 socket->read_ready(socket, socket->context);
225 }
226
internal_write_ready(void * context)227 static void internal_write_ready(void *context) {
228 assert(context != NULL);
229
230 socket_t *socket = (void *)context;
231 socket->write_ready(socket, socket->context);
232 }
233