sockets.c revision 2ca3e6b35f79136418ebc32fef57580698dbd045
1692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren/* 2692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren * Copyright (C) 2007 The Android Open Source Project 3692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren * 4692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren * Licensed under the Apache License, Version 2.0 (the "License"); 5692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren * you may not use this file except in compliance with the License. 6692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren * You may obtain a copy of the License at 7692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren * 8692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren * http://www.apache.org/licenses/LICENSE-2.0 9692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren * 10692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren * Unless required by applicable law or agreed to in writing, software 11692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren * distributed under the License is distributed on an "AS IS" BASIS, 12692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren * See the License for the specific language governing permissions and 14692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren * limitations under the License. 15692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren */ 16692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 17692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren#include <stdio.h> 18692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren#include <stdlib.h> 19692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren#include <unistd.h> 20692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren#include <errno.h> 21692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren#include <string.h> 22692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren#include <ctype.h> 23692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 24692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren#include "sysdeps.h" 25692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 26692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren#define TRACE_TAG TRACE_SOCKETS 27692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren#include "adb.h" 28692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 29692bb13352b9ad5166adc0dd55ae693d9181f611Chris WrenADB_MUTEX_DEFINE( socket_list_lock ); 30692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 31692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wrenstatic void local_socket_close_locked(asocket *s); 32692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 33692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wrenint sendfailmsg(int fd, const char *reason) 34692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren{ 35692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren char buf[9]; 36692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren int len; 37692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren len = strlen(reason); 38692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren if(len > 0xffff) len = 0xffff; 39692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren snprintf(buf, sizeof buf, "FAIL%04x", len); 40692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren if(writex(fd, buf, 8)) return -1; 41692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren return writex(fd, reason, len); 42692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren} 43692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 44692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren//extern int online; 45692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 46692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wrenstatic unsigned local_socket_next_id = 1; 47692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 48692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wrenstatic asocket local_socket_list = { 49692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren .next = &local_socket_list, 50692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren .prev = &local_socket_list, 51692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren}; 52692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 53692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren/* the the list of currently closing local sockets. 54692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren** these have no peer anymore, but still packets to 55692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren** write to their fd. 56692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren*/ 57692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wrenstatic asocket local_socket_closing_list = { 58692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren .next = &local_socket_closing_list, 59692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren .prev = &local_socket_closing_list, 60692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren}; 61692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 62692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wrenasocket *find_local_socket(unsigned id) 63692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren{ 64692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren asocket *s; 65692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren asocket *result = NULL; 66692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 67692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren adb_mutex_lock(&socket_list_lock); 68692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren for (s = local_socket_list.next; s != &local_socket_list; s = s->next) { 69692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren if (s->id == id) { 70692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren result = s; 71692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren break; 72692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren } 73692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren } 74692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren adb_mutex_unlock(&socket_list_lock); 75692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 76692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren return result; 77692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren} 78692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 79692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wrenstatic void 80692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wreninsert_local_socket(asocket* s, asocket* list) 81692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren{ 82692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren s->next = list; 83692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren s->prev = s->next->prev; 84692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren s->prev->next = s; 85692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren s->next->prev = s; 86692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren} 87692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 88692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 89692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wrenvoid install_local_socket(asocket *s) 90692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren{ 91692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren adb_mutex_lock(&socket_list_lock); 92692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 93692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren s->id = local_socket_next_id++; 94692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren insert_local_socket(s, &local_socket_list); 95692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 96692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren adb_mutex_unlock(&socket_list_lock); 97692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren} 98692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 99692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wrenvoid remove_socket(asocket *s) 100692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren{ 101692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren // socket_list_lock should already be held 102692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren if (s->prev && s->next) 1036fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani { 1046fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani s->prev->next = s->next; 1056fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani s->next->prev = s->prev; 1066fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani s->next = 0; 1076fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani s->prev = 0; 108692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren s->id = 0; 109692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren } 110692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren} 111692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 112692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wrenvoid close_all_sockets(atransport *t) 113692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren{ 114692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren asocket *s; 115692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 116692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren /* this is a little gross, but since s->close() *will* modify 117692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren ** the list out from under you, your options are limited. 118692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren */ 119692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren adb_mutex_lock(&socket_list_lock); 120692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wrenrestart: 121692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren for(s = local_socket_list.next; s != &local_socket_list; s = s->next){ 122692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren if(s->transport == t || (s->peer && s->peer->transport == t)) { 123692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren local_socket_close_locked(s); 124692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren goto restart; 125692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren } 126692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren } 127692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren adb_mutex_unlock(&socket_list_lock); 128692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren} 129692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 130692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wrenstatic int local_socket_enqueue(asocket *s, apacket *p) 131692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren{ 132692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren D("LS(%d): enqueue %d\n", s->id, p->len); 133692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 134692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren p->ptr = p->data; 135692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 136692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren /* if there is already data queue'd, we will receive 137692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren ** events when it's time to write. just add this to 138692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren ** the tail 139692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren */ 140692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren if(s->pkt_first) { 141692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren goto enqueue; 142692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren } 143692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 144692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren /* write as much as we can, until we 145692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren ** would block or there is an error/eof 146692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren */ 147692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren while(p->len > 0) { 148692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren int r = adb_write(s->fd, p->ptr, p->len); 149692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren if(r > 0) { 150692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren p->len -= r; 151692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren p->ptr += r; 152692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren continue; 153692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren } 154692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren if((r == 0) || (errno != EAGAIN)) { 155692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren D( "LS(%d): not ready, errno=%d: %s\n", s->id, errno, strerror(errno) ); 156692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren s->close(s); 157692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren return 1; /* not ready (error) */ 158692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren } else { 159692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren break; 160692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren } 161692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren } 162692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren 163692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren if(p->len == 0) { 164692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren put_apacket(p); 1656fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani return 0; /* ready for more data */ 1666fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani } 1676fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani 1686fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasanienqueue: 1696fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani p->next = 0; 1706fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani if(s->pkt_first) { 1716fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani s->pkt_last->next = p; 1726fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani } else { 1736fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani s->pkt_first = p; 1746fc1d4e8e6549b0d58ea23b4dd3f26329ec19f38Amith Yamasani } 175692bb13352b9ad5166adc0dd55ae693d9181f611Chris Wren s->pkt_last = p; 176 177 /* make sure we are notified when we can drain the queue */ 178 fdevent_add(&s->fde, FDE_WRITE); 179 180 return 1; /* not ready (backlog) */ 181} 182 183static void local_socket_ready(asocket *s) 184{ 185 /* far side is ready for data, pay attention to 186 readable events */ 187 fdevent_add(&s->fde, FDE_READ); 188// D("LS(%d): ready()\n", s->id); 189} 190 191static void local_socket_close(asocket *s) 192{ 193 adb_mutex_lock(&socket_list_lock); 194 local_socket_close_locked(s); 195 adb_mutex_unlock(&socket_list_lock); 196} 197 198// be sure to hold the socket list lock when calling this 199static void local_socket_destroy(asocket *s) 200{ 201 apacket *p, *n; 202 D("LS(%d): destroying fde.fd=%d\n", s->id, s->fde.fd); 203 204 /* IMPORTANT: the remove closes the fd 205 ** that belongs to this socket 206 */ 207 fdevent_remove(&s->fde); 208 209 /* dispose of any unwritten data */ 210 for(p = s->pkt_first; p; p = n) { 211 D("LS(%d): discarding %d bytes\n", s->id, p->len); 212 n = p->next; 213 put_apacket(p); 214 } 215 remove_socket(s); 216 free(s); 217} 218 219 220static void local_socket_close_locked(asocket *s) 221{ 222 D("entered. LS(%d) fd=%d\n", s->id, s->fd); 223 if(s->peer) { 224 D("LS(%d): closing peer. peer->id=%d peer->fd=%d\n", 225 s->id, s->peer->id, s->peer->fd); 226 s->peer->peer = 0; 227 // tweak to avoid deadlock 228 if (s->peer->close == local_socket_close) { 229 local_socket_close_locked(s->peer); 230 } else { 231 s->peer->close(s->peer); 232 } 233 s->peer = 0; 234 } 235 236 /* If we are already closing, or if there are no 237 ** pending packets, destroy immediately 238 */ 239 if (s->closing || s->pkt_first == NULL) { 240 int id = s->id; 241 local_socket_destroy(s); 242 D("LS(%d): closed\n", id); 243 return; 244 } 245 246 /* otherwise, put on the closing list 247 */ 248 D("LS(%d): closing\n", s->id); 249 s->closing = 1; 250 fdevent_del(&s->fde, FDE_READ); 251 remove_socket(s); 252 D("LS(%d): put on socket_closing_list fd=%d\n", s->id, s->fd); 253 insert_local_socket(s, &local_socket_closing_list); 254} 255 256static void local_socket_event_func(int fd, unsigned ev, void *_s) 257{ 258 asocket *s = _s; 259 260 D("LS(%d): event_func(fd=%d(==%d), ev=%04x)\n", s->id, s->fd, fd, ev); 261 262 /* put the FDE_WRITE processing before the FDE_READ 263 ** in order to simplify the code. 264 */ 265 if(ev & FDE_WRITE){ 266 apacket *p; 267 268 while((p = s->pkt_first) != 0) { 269 while(p->len > 0) { 270 int r = adb_write(fd, p->ptr, p->len); 271 if(r > 0) { 272 p->ptr += r; 273 p->len -= r; 274 continue; 275 } 276 if(r < 0) { 277 /* returning here is ok because FDE_READ will 278 ** be processed in the next iteration loop 279 */ 280 if(errno == EAGAIN) return; 281 if(errno == EINTR) continue; 282 } 283 D(" closing after write because r=%d and errno is %d\n", r, errno); 284 s->close(s); 285 return; 286 } 287 288 if(p->len == 0) { 289 s->pkt_first = p->next; 290 if(s->pkt_first == 0) s->pkt_last = 0; 291 put_apacket(p); 292 } 293 } 294 295 /* if we sent the last packet of a closing socket, 296 ** we can now destroy it. 297 */ 298 if (s->closing) { 299 D(" closing because 'closing' is set after write\n"); 300 s->close(s); 301 return; 302 } 303 304 /* no more packets queued, so we can ignore 305 ** writable events again and tell our peer 306 ** to resume writing 307 */ 308 fdevent_del(&s->fde, FDE_WRITE); 309 s->peer->ready(s->peer); 310 } 311 312 313 if(ev & FDE_READ){ 314 apacket *p = get_apacket(); 315 unsigned char *x = p->data; 316 size_t avail = MAX_PAYLOAD; 317 int r; 318 int is_eof = 0; 319 320 while(avail > 0) { 321 r = adb_read(fd, x, avail); 322 D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%d\n", s->id, s->fd, r, r<0?errno:0, avail); 323 if(r > 0) { 324 avail -= r; 325 x += r; 326 continue; 327 } 328 if(r < 0) { 329 if(errno == EAGAIN) break; 330 if(errno == EINTR) continue; 331 } 332 333 /* r = 0 or unhandled error */ 334 is_eof = 1; 335 break; 336 } 337 D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d\n", 338 s->id, s->fd, r, is_eof, s->fde.force_eof); 339 if((avail == MAX_PAYLOAD) || (s->peer == 0)) { 340 put_apacket(p); 341 } else { 342 p->len = MAX_PAYLOAD - avail; 343 344 r = s->peer->enqueue(s->peer, p); 345 D("LS(%d): fd=%d post peer->enqueue(). r=%d\n", s->id, s->fd, r); 346 347 if(r < 0) { 348 /* error return means they closed us as a side-effect 349 ** and we must return immediately. 350 ** 351 ** note that if we still have buffered packets, the 352 ** socket will be placed on the closing socket list. 353 ** this handler function will be called again 354 ** to process FDE_WRITE events. 355 */ 356 return; 357 } 358 359 if(r > 0) { 360 /* if the remote cannot accept further events, 361 ** we disable notification of READs. They'll 362 ** be enabled again when we get a call to ready() 363 */ 364 fdevent_del(&s->fde, FDE_READ); 365 } 366 } 367 /* Don't allow a forced eof if data is still there */ 368 if((s->fde.force_eof && !r) || is_eof) { 369 D(" closing because is_eof=%d r=%d s->fde.force_eof=%d\n", is_eof, r, s->fde.force_eof); 370 s->close(s); 371 } 372 } 373 374 if(ev & FDE_ERROR){ 375 /* this should be caught be the next read or write 376 ** catching it here means we may skip the last few 377 ** bytes of readable data. 378 */ 379// s->close(s); 380 D("LS(%d): FDE_ERROR (fd=%d)\n", s->id, s->fd); 381 382 return; 383 } 384} 385 386asocket *create_local_socket(int fd) 387{ 388 asocket *s = calloc(1, sizeof(asocket)); 389 if (s == NULL) fatal("cannot allocate socket"); 390 s->fd = fd; 391 s->enqueue = local_socket_enqueue; 392 s->ready = local_socket_ready; 393 s->close = local_socket_close; 394 install_local_socket(s); 395 396 fdevent_install(&s->fde, fd, local_socket_event_func, s); 397/* fdevent_add(&s->fde, FDE_ERROR); */ 398 //fprintf(stderr, "Created local socket in create_local_socket \n"); 399 D("LS(%d): created (fd=%d)\n", s->id, s->fd); 400 return s; 401} 402 403asocket *create_local_service_socket(const char *name) 404{ 405 asocket *s; 406 int fd; 407 408#if !ADB_HOST 409 if (!strcmp(name,"jdwp")) { 410 return create_jdwp_service_socket(); 411 } 412 if (!strcmp(name,"track-jdwp")) { 413 return create_jdwp_tracker_service_socket(); 414 } 415#endif 416 fd = service_to_fd(name); 417 if(fd < 0) return 0; 418 419 s = create_local_socket(fd); 420 D("LS(%d): bound to '%s' via %d\n", s->id, name, fd); 421 return s; 422} 423 424#if ADB_HOST 425static asocket *create_host_service_socket(const char *name, const char* serial) 426{ 427 asocket *s; 428 429 s = host_service_to_socket(name, serial); 430 431 if (s != NULL) { 432 D("LS(%d) bound to '%s'\n", s->id, name); 433 return s; 434 } 435 436 return s; 437} 438#endif /* ADB_HOST */ 439 440/* a Remote socket is used to send/receive data to/from a given transport object 441** it needs to be closed when the transport is forcibly destroyed by the user 442*/ 443typedef struct aremotesocket { 444 asocket socket; 445 adisconnect disconnect; 446} aremotesocket; 447 448static int remote_socket_enqueue(asocket *s, apacket *p) 449{ 450 D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d\n", 451 s->id, s->fd, s->peer->fd); 452 p->msg.command = A_WRTE; 453 p->msg.arg0 = s->peer->id; 454 p->msg.arg1 = s->id; 455 p->msg.data_length = p->len; 456 send_packet(p, s->transport); 457 return 1; 458} 459 460static void remote_socket_ready(asocket *s) 461{ 462 D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d\n", 463 s->id, s->fd, s->peer->fd); 464 apacket *p = get_apacket(); 465 p->msg.command = A_OKAY; 466 p->msg.arg0 = s->peer->id; 467 p->msg.arg1 = s->id; 468 send_packet(p, s->transport); 469} 470 471static void remote_socket_close(asocket *s) 472{ 473 D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d\n", 474 s->id, s->fd, s->peer?s->peer->fd:-1); 475 apacket *p = get_apacket(); 476 p->msg.command = A_CLSE; 477 if(s->peer) { 478 p->msg.arg0 = s->peer->id; 479 s->peer->peer = 0; 480 D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d\n", 481 s->id, s->peer->id, s->peer->fd); 482 s->peer->close(s->peer); 483 } 484 p->msg.arg1 = s->id; 485 send_packet(p, s->transport); 486 D("RS(%d): closed\n", s->id); 487 remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect ); 488 free(s); 489} 490 491static void remote_socket_disconnect(void* _s, atransport* t) 492{ 493 asocket* s = _s; 494 asocket* peer = s->peer; 495 496 D("remote_socket_disconnect RS(%d)\n", s->id); 497 if (peer) { 498 peer->peer = NULL; 499 peer->close(peer); 500 } 501 remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect ); 502 free(s); 503} 504 505asocket *create_remote_socket(unsigned id, atransport *t) 506{ 507 asocket *s = calloc(1, sizeof(aremotesocket)); 508 adisconnect* dis = &((aremotesocket*)s)->disconnect; 509 510 if (s == NULL) fatal("cannot allocate socket"); 511 s->id = id; 512 s->enqueue = remote_socket_enqueue; 513 s->ready = remote_socket_ready; 514 s->close = remote_socket_close; 515 s->transport = t; 516 517 dis->func = remote_socket_disconnect; 518 dis->opaque = s; 519 add_transport_disconnect( t, dis ); 520 D("RS(%d): created\n", s->id); 521 return s; 522} 523 524void connect_to_remote(asocket *s, const char *destination) 525{ 526 D("Connect_to_remote call RS(%d) fd=%d\n", s->id, s->fd); 527 apacket *p = get_apacket(); 528 int len = strlen(destination) + 1; 529 530 if(len > (MAX_PAYLOAD-1)) { 531 fatal("destination oversized"); 532 } 533 534 D("LS(%d): connect('%s')\n", s->id, destination); 535 p->msg.command = A_OPEN; 536 p->msg.arg0 = s->id; 537 p->msg.data_length = len; 538 strcpy((char*) p->data, destination); 539 send_packet(p, s->transport); 540} 541 542 543/* this is used by magic sockets to rig local sockets to 544 send the go-ahead message when they connect */ 545static void local_socket_ready_notify(asocket *s) 546{ 547 s->ready = local_socket_ready; 548 s->close = local_socket_close; 549 adb_write(s->fd, "OKAY", 4); 550 s->ready(s); 551} 552 553/* this is used by magic sockets to rig local sockets to 554 send the failure message if they are closed before 555 connected (to avoid closing them without a status message) */ 556static void local_socket_close_notify(asocket *s) 557{ 558 s->ready = local_socket_ready; 559 s->close = local_socket_close; 560 sendfailmsg(s->fd, "closed"); 561 s->close(s); 562} 563 564unsigned unhex(unsigned char *s, int len) 565{ 566 unsigned n = 0, c; 567 568 while(len-- > 0) { 569 switch((c = *s++)) { 570 case '0': case '1': case '2': 571 case '3': case '4': case '5': 572 case '6': case '7': case '8': 573 case '9': 574 c -= '0'; 575 break; 576 case 'a': case 'b': case 'c': 577 case 'd': case 'e': case 'f': 578 c = c - 'a' + 10; 579 break; 580 case 'A': case 'B': case 'C': 581 case 'D': case 'E': case 'F': 582 c = c - 'A' + 10; 583 break; 584 default: 585 return 0xffffffff; 586 } 587 588 n = (n << 4) | c; 589 } 590 591 return n; 592} 593 594#define PREFIX(str) { str, sizeof(str) - 1 } 595static const struct prefix_struct { 596 const char *str; 597 const size_t len; 598} prefixes[] = { 599 PREFIX("usb:"), 600 PREFIX("product:"), 601 PREFIX("model:"), 602 PREFIX("device:"), 603}; 604static const int num_prefixes = (sizeof(prefixes) / sizeof(prefixes[0])); 605 606/* skip_host_serial return the position in a string 607 skipping over the 'serial' parameter in the ADB protocol, 608 where parameter string may be a host:port string containing 609 the protocol delimiter (colon). */ 610char *skip_host_serial(char *service) { 611 char *first_colon, *serial_end; 612 int i; 613 614 for (i = 0; i < num_prefixes; i++) { 615 if (!strncmp(service, prefixes[i].str, prefixes[i].len)) 616 return strchr(service + prefixes[i].len, ':'); 617 } 618 619 first_colon = strchr(service, ':'); 620 if (!first_colon) { 621 /* No colon in service string. */ 622 return NULL; 623 } 624 serial_end = first_colon; 625 if (isdigit(serial_end[1])) { 626 serial_end++; 627 while ((*serial_end) && isdigit(*serial_end)) { 628 serial_end++; 629 } 630 if ((*serial_end) != ':') { 631 // Something other than numbers was found, reset the end. 632 serial_end = first_colon; 633 } 634 } 635 return serial_end; 636} 637 638static int smart_socket_enqueue(asocket *s, apacket *p) 639{ 640 unsigned len; 641#if ADB_HOST 642 char *service = NULL; 643 char* serial = NULL; 644 transport_type ttype = kTransportAny; 645#endif 646 647 D("SS(%d): enqueue %d\n", s->id, p->len); 648 649 if(s->pkt_first == 0) { 650 s->pkt_first = p; 651 s->pkt_last = p; 652 } else { 653 if((s->pkt_first->len + p->len) > MAX_PAYLOAD) { 654 D("SS(%d): overflow\n", s->id); 655 put_apacket(p); 656 goto fail; 657 } 658 659 memcpy(s->pkt_first->data + s->pkt_first->len, 660 p->data, p->len); 661 s->pkt_first->len += p->len; 662 put_apacket(p); 663 664 p = s->pkt_first; 665 } 666 667 /* don't bother if we can't decode the length */ 668 if(p->len < 4) return 0; 669 670 len = unhex(p->data, 4); 671 if((len < 1) || (len > 1024)) { 672 D("SS(%d): bad size (%d)\n", s->id, len); 673 goto fail; 674 } 675 676 D("SS(%d): len is %d\n", s->id, len ); 677 /* can't do anything until we have the full header */ 678 if((len + 4) > p->len) { 679 D("SS(%d): waiting for %d more bytes\n", s->id, len+4 - p->len); 680 return 0; 681 } 682 683 p->data[len + 4] = 0; 684 685 D("SS(%d): '%s'\n", s->id, (char*) (p->data + 4)); 686 687#if ADB_HOST 688 service = (char *)p->data + 4; 689 if(!strncmp(service, "host-serial:", strlen("host-serial:"))) { 690 char* serial_end; 691 service += strlen("host-serial:"); 692 693 // serial number should follow "host:" and could be a host:port string. 694 serial_end = skip_host_serial(service); 695 if (serial_end) { 696 *serial_end = 0; // terminate string 697 serial = service; 698 service = serial_end + 1; 699 } 700 } else if (!strncmp(service, "host-usb:", strlen("host-usb:"))) { 701 ttype = kTransportUsb; 702 service += strlen("host-usb:"); 703 } else if (!strncmp(service, "host-local:", strlen("host-local:"))) { 704 ttype = kTransportLocal; 705 service += strlen("host-local:"); 706 } else if (!strncmp(service, "host:", strlen("host:"))) { 707 ttype = kTransportAny; 708 service += strlen("host:"); 709 } else { 710 service = NULL; 711 } 712 713 if (service) { 714 asocket *s2; 715 716 /* some requests are handled immediately -- in that 717 ** case the handle_host_request() routine has sent 718 ** the OKAY or FAIL message and all we have to do 719 ** is clean up. 720 */ 721 if(handle_host_request(service, ttype, serial, s->peer->fd, s) == 0) { 722 /* XXX fail message? */ 723 D( "SS(%d): handled host service '%s'\n", s->id, service ); 724 goto fail; 725 } 726 if (!strncmp(service, "transport", strlen("transport"))) { 727 D( "SS(%d): okay transport\n", s->id ); 728 p->len = 0; 729 return 0; 730 } 731 732 /* try to find a local service with this name. 733 ** if no such service exists, we'll fail out 734 ** and tear down here. 735 */ 736 s2 = create_host_service_socket(service, serial); 737 if(s2 == 0) { 738 D( "SS(%d): couldn't create host service '%s'\n", s->id, service ); 739 sendfailmsg(s->peer->fd, "unknown host service"); 740 goto fail; 741 } 742 743 /* we've connected to a local host service, 744 ** so we make our peer back into a regular 745 ** local socket and bind it to the new local 746 ** service socket, acknowledge the successful 747 ** connection, and close this smart socket now 748 ** that its work is done. 749 */ 750 adb_write(s->peer->fd, "OKAY", 4); 751 752 s->peer->ready = local_socket_ready; 753 s->peer->close = local_socket_close; 754 s->peer->peer = s2; 755 s2->peer = s->peer; 756 s->peer = 0; 757 D( "SS(%d): okay\n", s->id ); 758 s->close(s); 759 760 /* initial state is "ready" */ 761 s2->ready(s2); 762 return 0; 763 } 764#else /* !ADB_HOST */ 765 if (s->transport == NULL) { 766 char* error_string = "unknown failure"; 767 s->transport = acquire_one_transport (CS_ANY, 768 kTransportAny, NULL, &error_string); 769 770 if (s->transport == NULL) { 771 sendfailmsg(s->peer->fd, error_string); 772 goto fail; 773 } 774 } 775#endif 776 777 if(!(s->transport) || (s->transport->connection_state == CS_OFFLINE)) { 778 /* if there's no remote we fail the connection 779 ** right here and terminate it 780 */ 781 sendfailmsg(s->peer->fd, "device offline (x)"); 782 goto fail; 783 } 784 785 786 /* instrument our peer to pass the success or fail 787 ** message back once it connects or closes, then 788 ** detach from it, request the connection, and 789 ** tear down 790 */ 791 s->peer->ready = local_socket_ready_notify; 792 s->peer->close = local_socket_close_notify; 793 s->peer->peer = 0; 794 /* give him our transport and upref it */ 795 s->peer->transport = s->transport; 796 797 connect_to_remote(s->peer, (char*) (p->data + 4)); 798 s->peer = 0; 799 s->close(s); 800 return 1; 801 802fail: 803 /* we're going to close our peer as a side-effect, so 804 ** return -1 to signal that state to the local socket 805 ** who is enqueueing against us 806 */ 807 s->close(s); 808 return -1; 809} 810 811static void smart_socket_ready(asocket *s) 812{ 813 D("SS(%d): ready\n", s->id); 814} 815 816static void smart_socket_close(asocket *s) 817{ 818 D("SS(%d): closed\n", s->id); 819 if(s->pkt_first){ 820 put_apacket(s->pkt_first); 821 } 822 if(s->peer) { 823 s->peer->peer = 0; 824 s->peer->close(s->peer); 825 s->peer = 0; 826 } 827 free(s); 828} 829 830asocket *create_smart_socket(void (*action_cb)(asocket *s, const char *act)) 831{ 832 D("Creating smart socket \n"); 833 asocket *s = calloc(1, sizeof(asocket)); 834 if (s == NULL) fatal("cannot allocate socket"); 835 s->enqueue = smart_socket_enqueue; 836 s->ready = smart_socket_ready; 837 s->close = smart_socket_close; 838 s->extra = action_cb; 839 840 D("SS(%d): created %p\n", s->id, action_cb); 841 return s; 842} 843 844void smart_socket_action(asocket *s, const char *act) 845{ 846 847} 848 849void connect_to_smartsocket(asocket *s) 850{ 851 D("Connecting to smart socket \n"); 852 asocket *ss = create_smart_socket(smart_socket_action); 853 s->peer = ss; 854 ss->peer = s; 855 s->ready(s); 856} 857