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