1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "jsonrpc_internal.h" 35 36 struct spdk_jsonrpc_server * 37 spdk_jsonrpc_server_listen(int domain, int protocol, 38 struct sockaddr *listen_addr, socklen_t addrlen, 39 spdk_jsonrpc_handle_request_fn handle_request) 40 { 41 struct spdk_jsonrpc_server *server; 42 int rc, val; 43 44 server = calloc(1, sizeof(struct spdk_jsonrpc_server)); 45 if (server == NULL) { 46 return NULL; 47 } 48 49 server->handle_request = handle_request; 50 51 server->sockfd = socket(domain, SOCK_STREAM, protocol); 52 if (server->sockfd < 0) { 53 SPDK_ERRLOG("socket() failed\n"); 54 free(server); 55 return NULL; 56 } 57 58 val = 1; 59 setsockopt(server->sockfd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)); 60 if (protocol == IPPROTO_TCP) { 61 setsockopt(server->sockfd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val)); 62 } 63 64 val = 1; 65 rc = ioctl(server->sockfd, FIONBIO, &val); 66 if (rc != 0) { 67 SPDK_ERRLOG("ioctl(FIONBIO) failed\n"); 68 close(server->sockfd); 69 free(server); 70 return NULL; 71 } 72 73 rc = bind(server->sockfd, listen_addr, addrlen); 74 if (rc != 0) { 75 SPDK_ERRLOG("could not bind JSON-RPC server: %s\n", strerror(errno)); 76 close(server->sockfd); 77 free(server); 78 return NULL; 79 } 80 81 rc = listen(server->sockfd, 512); 82 if (rc != 0) { 83 SPDK_ERRLOG("listen() failed, errno = %d\n", errno); 84 close(server->sockfd); 85 free(server); 86 return NULL; 87 } 88 89 /* Put listen socket in pollfds[0] */ 90 server->pollfds[0].fd = server->sockfd; 91 server->pollfds[0].events = POLLIN; 92 93 return server; 94 } 95 96 void 97 spdk_jsonrpc_server_shutdown(struct spdk_jsonrpc_server *server) 98 { 99 int i; 100 101 close(server->sockfd); 102 103 for (i = 0; i < server->num_conns; i++) { 104 close(server->conns[i].sockfd); 105 } 106 107 free(server); 108 } 109 110 static void 111 spdk_jsonrpc_server_conn_remove(struct spdk_jsonrpc_server_conn *conn) 112 { 113 struct spdk_jsonrpc_server *server = conn->server; 114 int conn_idx = conn - server->conns; 115 116 close(conn->sockfd); 117 118 /* Swap conn with the last entry in conns */ 119 server->conns[conn_idx] = server->conns[server->num_conns - 1]; 120 server->num_conns--; 121 } 122 123 static int 124 spdk_jsonrpc_server_accept(struct spdk_jsonrpc_server *server) 125 { 126 struct spdk_jsonrpc_server_conn *conn; 127 struct pollfd *pfd; 128 int rc, conn_idx, nonblock; 129 130 rc = accept(server->sockfd, NULL, NULL); 131 if (rc >= 0) { 132 assert(server->num_conns < SPDK_JSONRPC_MAX_CONNS); 133 conn_idx = server->num_conns; 134 conn = &server->conns[conn_idx]; 135 conn->server = server; 136 conn->sockfd = rc; 137 conn->recv_len = 0; 138 conn->send_len = 0; 139 conn->json_writer = 0; 140 141 nonblock = 1; 142 rc = ioctl(conn->sockfd, FIONBIO, &nonblock); 143 if (rc != 0) { 144 SPDK_ERRLOG("ioctl(FIONBIO) failed\n"); 145 close(conn->sockfd); 146 return -1; 147 } 148 149 /* Add connection to pollfds */ 150 pfd = &server->pollfds[conn_idx + 1]; 151 pfd->fd = conn->sockfd; 152 pfd->events = POLLIN | POLLOUT; 153 154 server->num_conns++; 155 156 return 0; 157 } 158 159 if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) { 160 return 0; 161 } 162 163 return -1; 164 } 165 166 int 167 spdk_jsonrpc_server_write_cb(void *cb_ctx, const void *data, size_t size) 168 { 169 struct spdk_jsonrpc_server_conn *conn = cb_ctx; 170 171 if (SPDK_JSONRPC_SEND_BUF_SIZE - conn->send_len < size) { 172 SPDK_ERRLOG("Not enough space in send buf\n"); 173 return -1; 174 } 175 176 memcpy(conn->send_buf + conn->send_len, data, size); 177 conn->send_len += size; 178 179 return 0; 180 } 181 182 void 183 spdk_jsonrpc_server_handle_request(struct spdk_jsonrpc_request *request, 184 const struct spdk_json_val *method, const struct spdk_json_val *params) 185 { 186 request->conn->server->handle_request(request, method, params); 187 } 188 189 void 190 spdk_jsonrpc_server_handle_error(struct spdk_jsonrpc_request *request, int error) 191 { 192 const char *msg; 193 194 switch (error) { 195 case SPDK_JSONRPC_ERROR_PARSE_ERROR: 196 msg = "Parse error"; 197 break; 198 199 case SPDK_JSONRPC_ERROR_INVALID_REQUEST: 200 msg = "Invalid request"; 201 break; 202 203 case SPDK_JSONRPC_ERROR_METHOD_NOT_FOUND: 204 msg = "Method not found"; 205 break; 206 207 case SPDK_JSONRPC_ERROR_INVALID_PARAMS: 208 msg = "Invalid parameters"; 209 break; 210 211 case SPDK_JSONRPC_ERROR_INTERNAL_ERROR: 212 msg = "Internal error"; 213 break; 214 215 default: 216 msg = "Error"; 217 break; 218 } 219 220 spdk_jsonrpc_send_error_response(request, error, msg); 221 } 222 223 static int 224 spdk_jsonrpc_server_conn_recv(struct spdk_jsonrpc_server_conn *conn) 225 { 226 ssize_t rc; 227 size_t recv_avail = SPDK_JSONRPC_RECV_BUF_SIZE - conn->recv_len; 228 229 rc = recv(conn->sockfd, conn->recv_buf + conn->recv_len, recv_avail, 0); 230 if (rc == -1) { 231 if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) { 232 return 0; 233 } 234 235 SPDK_TRACELOG(SPDK_TRACE_RPC, "recv() failed: %s\n", strerror(errno)); 236 return -1; 237 } 238 239 if (rc == 0) { 240 SPDK_TRACELOG(SPDK_TRACE_RPC, "remote closed connection\n"); 241 return -1; 242 } 243 244 conn->recv_len += rc; 245 246 rc = spdk_jsonrpc_parse_request(conn, conn->recv_buf, conn->recv_len); 247 if (rc < 0) { 248 SPDK_ERRLOG("jsonrpc parse request failed\n"); 249 return -1; 250 } 251 252 if (rc > 0) { 253 /* 254 * Successfully parsed a request - move any data past the end of the 255 * parsed request down to the beginning. 256 */ 257 assert((size_t)rc <= conn->recv_len); 258 memmove(conn->recv_buf, conn->recv_buf + rc, conn->recv_len - rc); 259 conn->recv_len -= rc; 260 } 261 262 return 0; 263 } 264 265 static int 266 spdk_jsonrpc_server_conn_send(struct spdk_jsonrpc_server_conn *conn) 267 { 268 ssize_t rc; 269 270 rc = send(conn->sockfd, conn->send_buf, conn->send_len, 0); 271 if (rc < 0) { 272 if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) { 273 return 0; 274 } 275 276 SPDK_TRACELOG(SPDK_TRACE_RPC, "send() failed: %s\n", strerror(errno)); 277 return -1; 278 } 279 280 if (rc == 0) { 281 SPDK_TRACELOG(SPDK_TRACE_RPC, "remote closed connection\n"); 282 return -1; 283 } 284 285 conn->send_len -= rc; 286 287 return 0; 288 } 289 290 int 291 spdk_jsonrpc_server_poll(struct spdk_jsonrpc_server *server) 292 { 293 int rc, i; 294 struct pollfd *pfd; 295 struct spdk_jsonrpc_server_conn *conn; 296 297 rc = poll(server->pollfds, server->num_conns + 1, 0); 298 299 if (rc < 0) { 300 if (errno == EINTR) { 301 return 0; 302 } 303 304 SPDK_ERRLOG("jsonrpc poll() failed\n"); 305 return -1; 306 } 307 308 if (rc == 0) { 309 /* No sockets are ready */ 310 return 0; 311 } 312 313 /* Check listen socket */ 314 if (server->num_conns < SPDK_JSONRPC_MAX_CONNS) { 315 pfd = &server->pollfds[0]; 316 if (pfd->revents) { 317 spdk_jsonrpc_server_accept(server); 318 } 319 pfd->revents = 0; 320 } 321 322 for (i = 0; i < server->num_conns; i++) { 323 pfd = &server->pollfds[i + 1]; 324 conn = &server->conns[i]; 325 if (conn->send_len) { 326 /* 327 * If there is any data to send, keep sending it until the send buffer 328 * is empty. Each response should be allowed the full send buffer, so 329 * don't accept any new requests until the previous response is sent out. 330 */ 331 if (pfd->revents & POLLOUT) { 332 rc = spdk_jsonrpc_server_conn_send(conn); 333 if (rc != 0) { 334 SPDK_TRACELOG(SPDK_TRACE_RPC, "closing conn due to send failure\n"); 335 spdk_jsonrpc_server_conn_remove(conn); 336 } 337 } 338 } else { 339 /* 340 * No data to send - we can receive a new request. 341 */ 342 if (pfd->revents & POLLIN) { 343 rc = spdk_jsonrpc_server_conn_recv(conn); 344 if (rc != 0) { 345 SPDK_TRACELOG(SPDK_TRACE_RPC, "closing conn due to recv failure\n"); 346 spdk_jsonrpc_server_conn_remove(conn); 347 } 348 } 349 } 350 pfd->revents = 0; 351 } 352 353 return 0; 354 } 355