1 /*- 2 * service.c 3 * 4 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 5 * 6 * Copyright (c) 2001-2003 Maksim Yevmenkin <m_evmenkin@yahoo.com> 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 * 30 * $Id: service.c,v 1.1 2004/01/13 19:32:36 max Exp $ 31 * $FreeBSD$ 32 */ 33 34 #include <sys/uio.h> 35 #include <netinet/in.h> 36 #include <arpa/inet.h> 37 #define L2CAP_SOCKET_CHECKED 38 #include <bluetooth.h> 39 #include <errno.h> 40 #include <string.h> 41 #include <unistd.h> 42 43 #include <sdp-int.h> 44 #include <sdp.h> 45 46 static int32_t sdp_receive_error_pdu(sdp_session_p ss); 47 48 int32_t 49 sdp_register_service(void *xss, uint16_t uuid, bdaddr_p const bdaddr, 50 uint8_t const *data, uint32_t datalen, uint32_t *handle) 51 { 52 sdp_session_p ss = (sdp_session_p) xss; 53 struct iovec iov[4]; 54 sdp_pdu_t pdu; 55 int32_t len; 56 57 if (ss == NULL) 58 return (-1); 59 if (bdaddr == NULL || data == NULL || 60 datalen == 0 || !(ss->flags & SDP_SESSION_LOCAL)) { 61 ss->error = EINVAL; 62 return (-1); 63 } 64 if (sizeof(pdu)+sizeof(uuid)+sizeof(*bdaddr)+datalen > SDP_LOCAL_MTU) { 65 ss->error = EMSGSIZE; 66 return (-1); 67 } 68 69 pdu.pid = SDP_PDU_SERVICE_REGISTER_REQUEST; 70 pdu.tid = htons(++ss->tid); 71 pdu.len = htons(sizeof(uuid) + sizeof(*bdaddr) + datalen); 72 73 uuid = htons(uuid); 74 75 iov[0].iov_base = (void *) &pdu; 76 iov[0].iov_len = sizeof(pdu); 77 78 iov[1].iov_base = (void *) &uuid; 79 iov[1].iov_len = sizeof(uuid); 80 81 iov[2].iov_base = (void *) bdaddr; 82 iov[2].iov_len = sizeof(*bdaddr); 83 84 iov[3].iov_base = (void *) data; 85 iov[3].iov_len = datalen; 86 87 do { 88 len = writev(ss->s, iov, sizeof(iov)/sizeof(iov[0])); 89 } while (len < 0 && errno == EINTR); 90 91 if (len < 0) { 92 ss->error = errno; 93 return (-1); 94 } 95 96 len = sdp_receive_error_pdu(ss); 97 if (len < 0) 98 return (-1); 99 if (len != sizeof(pdu) + sizeof(uint16_t) + sizeof(uint32_t)) { 100 ss->error = EIO; 101 return (-1); 102 } 103 104 if (handle != NULL) { 105 *handle = (uint32_t) ss->rsp[--len]; 106 *handle |= (uint32_t) ss->rsp[--len] << 8; 107 *handle |= (uint32_t) ss->rsp[--len] << 16; 108 *handle |= (uint32_t) ss->rsp[--len] << 24; 109 } 110 111 return (0); 112 } 113 114 int32_t 115 sdp_unregister_service(void *xss, uint32_t handle) 116 { 117 sdp_session_p ss = (sdp_session_p) xss; 118 struct iovec iov[2]; 119 sdp_pdu_t pdu; 120 int32_t len; 121 122 if (ss == NULL) 123 return (-1); 124 if (!(ss->flags & SDP_SESSION_LOCAL)) { 125 ss->error = EINVAL; 126 return (-1); 127 } 128 if (sizeof(pdu) + sizeof(handle) > SDP_LOCAL_MTU) { 129 ss->error = EMSGSIZE; 130 return (-1); 131 } 132 133 pdu.pid = SDP_PDU_SERVICE_UNREGISTER_REQUEST; 134 pdu.tid = htons(++ss->tid); 135 pdu.len = htons(sizeof(handle)); 136 137 handle = htonl(handle); 138 139 iov[0].iov_base = (void *) &pdu; 140 iov[0].iov_len = sizeof(pdu); 141 142 iov[1].iov_base = (void *) &handle; 143 iov[1].iov_len = sizeof(handle); 144 145 do { 146 len = writev(ss->s, iov, sizeof(iov)/sizeof(iov[0])); 147 } while (len < 0 && errno == EINTR); 148 149 if (len < 0) { 150 ss->error = errno; 151 return (-1); 152 } 153 154 return ((sdp_receive_error_pdu(ss) < 0)? -1 : 0); 155 } 156 157 int32_t 158 sdp_change_service(void *xss, uint32_t handle, 159 uint8_t const *data, uint32_t datalen) 160 { 161 sdp_session_p ss = (sdp_session_p) xss; 162 struct iovec iov[3]; 163 sdp_pdu_t pdu; 164 int32_t len; 165 166 if (ss == NULL) 167 return (-1); 168 if (data == NULL || datalen == 0 || !(ss->flags & SDP_SESSION_LOCAL)) { 169 ss->error = EINVAL; 170 return (-1); 171 } 172 if (sizeof(pdu) + sizeof(handle) + datalen > SDP_LOCAL_MTU) { 173 ss->error = EMSGSIZE; 174 return (-1); 175 } 176 177 pdu.pid = SDP_PDU_SERVICE_CHANGE_REQUEST; 178 pdu.tid = htons(++ss->tid); 179 pdu.len = htons(sizeof(handle) + datalen); 180 181 handle = htons(handle); 182 183 iov[0].iov_base = (void *) &pdu; 184 iov[0].iov_len = sizeof(pdu); 185 186 iov[1].iov_base = (void *) &handle; 187 iov[1].iov_len = sizeof(handle); 188 189 iov[2].iov_base = (void *) data; 190 iov[2].iov_len = datalen; 191 192 do { 193 len = writev(ss->s, iov, sizeof(iov)/sizeof(iov[0])); 194 } while (len < 0 && errno == EINTR); 195 196 if (len < 0) { 197 ss->error = errno; 198 return (-1); 199 } 200 201 return ((sdp_receive_error_pdu(ss) < 0)? -1 : 0); 202 } 203 204 static int32_t 205 sdp_receive_error_pdu(sdp_session_p ss) 206 { 207 sdp_pdu_p pdu; 208 int32_t len; 209 uint16_t error; 210 211 do { 212 len = read(ss->s, ss->rsp, ss->rsp_e - ss->rsp); 213 } while (len < 0 && errno == EINTR); 214 215 if (len < 0) { 216 ss->error = errno; 217 return (-1); 218 } 219 220 pdu = (sdp_pdu_p) ss->rsp; 221 pdu->tid = ntohs(pdu->tid); 222 pdu->len = ntohs(pdu->len); 223 224 if (pdu->pid != SDP_PDU_ERROR_RESPONSE || pdu->tid != ss->tid || 225 pdu->len < 2 || pdu->len != len - sizeof(*pdu)) { 226 ss->error = EIO; 227 return (-1); 228 } 229 230 error = (uint16_t) ss->rsp[sizeof(pdu)] << 8; 231 error |= (uint16_t) ss->rsp[sizeof(pdu) + 1]; 232 233 if (error != 0) { 234 ss->error = EIO; 235 return (-1); 236 } 237 238 return (len); 239 } 240 241