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