2009-03-04 11:32:55 +08:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2007 The Android Open Source Project
|
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
|
|
|
|
#include "sysdeps.h"
|
|
|
|
|
|
|
|
#define TRACE_TAG TRACE_SOCKETS
|
|
|
|
#include "adb.h"
|
|
|
|
|
|
|
|
ADB_MUTEX_DEFINE( socket_list_lock );
|
|
|
|
|
|
|
|
static void local_socket_close_locked(asocket *s);
|
|
|
|
|
|
|
|
int sendfailmsg(int fd, const char *reason)
|
|
|
|
{
|
|
|
|
char buf[9];
|
|
|
|
int len;
|
|
|
|
len = strlen(reason);
|
|
|
|
if(len > 0xffff) len = 0xffff;
|
|
|
|
snprintf(buf, sizeof buf, "FAIL%04x", len);
|
|
|
|
if(writex(fd, buf, 8)) return -1;
|
|
|
|
return writex(fd, reason, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
//extern int online;
|
|
|
|
|
|
|
|
static unsigned local_socket_next_id = 1;
|
|
|
|
|
|
|
|
static asocket local_socket_list = {
|
|
|
|
.next = &local_socket_list,
|
|
|
|
.prev = &local_socket_list,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* the the list of currently closing local sockets.
|
|
|
|
** these have no peer anymore, but still packets to
|
|
|
|
** write to their fd.
|
|
|
|
*/
|
|
|
|
static asocket local_socket_closing_list = {
|
|
|
|
.next = &local_socket_closing_list,
|
|
|
|
.prev = &local_socket_closing_list,
|
|
|
|
};
|
|
|
|
|
2013-12-13 21:09:44 +08:00
|
|
|
// Parse the global list of sockets to find one with id |local_id|.
|
|
|
|
// If |peer_id| is not 0, also check that it is connected to a peer
|
|
|
|
// with id |peer_id|. Returns an asocket handle on success, NULL on failure.
|
|
|
|
asocket *find_local_socket(unsigned local_id, unsigned peer_id)
|
2009-03-04 11:32:55 +08:00
|
|
|
{
|
|
|
|
asocket *s;
|
|
|
|
asocket *result = NULL;
|
|
|
|
|
|
|
|
adb_mutex_lock(&socket_list_lock);
|
2010-06-12 22:40:20 +08:00
|
|
|
for (s = local_socket_list.next; s != &local_socket_list; s = s->next) {
|
2013-12-13 21:09:44 +08:00
|
|
|
if (s->id != local_id)
|
|
|
|
continue;
|
|
|
|
if (peer_id == 0 || (s->peer && s->peer->id == peer_id)) {
|
2010-06-12 22:40:20 +08:00
|
|
|
result = s;
|
|
|
|
}
|
2013-12-13 21:09:44 +08:00
|
|
|
break;
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
adb_mutex_unlock(&socket_list_lock);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
insert_local_socket(asocket* s, asocket* list)
|
|
|
|
{
|
|
|
|
s->next = list;
|
|
|
|
s->prev = s->next->prev;
|
|
|
|
s->prev->next = s;
|
|
|
|
s->next->prev = s;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void install_local_socket(asocket *s)
|
|
|
|
{
|
|
|
|
adb_mutex_lock(&socket_list_lock);
|
|
|
|
|
|
|
|
s->id = local_socket_next_id++;
|
2013-12-13 21:09:44 +08:00
|
|
|
|
|
|
|
// Socket ids should never be 0.
|
|
|
|
if (local_socket_next_id == 0)
|
|
|
|
local_socket_next_id = 1;
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
insert_local_socket(s, &local_socket_list);
|
|
|
|
|
|
|
|
adb_mutex_unlock(&socket_list_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
void remove_socket(asocket *s)
|
|
|
|
{
|
|
|
|
// socket_list_lock should already be held
|
|
|
|
if (s->prev && s->next)
|
|
|
|
{
|
|
|
|
s->prev->next = s->next;
|
|
|
|
s->next->prev = s->prev;
|
|
|
|
s->next = 0;
|
|
|
|
s->prev = 0;
|
|
|
|
s->id = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void close_all_sockets(atransport *t)
|
|
|
|
{
|
|
|
|
asocket *s;
|
|
|
|
|
|
|
|
/* this is a little gross, but since s->close() *will* modify
|
|
|
|
** the list out from under you, your options are limited.
|
|
|
|
*/
|
|
|
|
adb_mutex_lock(&socket_list_lock);
|
|
|
|
restart:
|
|
|
|
for(s = local_socket_list.next; s != &local_socket_list; s = s->next){
|
|
|
|
if(s->transport == t || (s->peer && s->peer->transport == t)) {
|
|
|
|
local_socket_close_locked(s);
|
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
adb_mutex_unlock(&socket_list_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int local_socket_enqueue(asocket *s, apacket *p)
|
|
|
|
{
|
|
|
|
D("LS(%d): enqueue %d\n", s->id, p->len);
|
|
|
|
|
|
|
|
p->ptr = p->data;
|
|
|
|
|
|
|
|
/* if there is already data queue'd, we will receive
|
|
|
|
** events when it's time to write. just add this to
|
|
|
|
** the tail
|
|
|
|
*/
|
|
|
|
if(s->pkt_first) {
|
|
|
|
goto enqueue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* write as much as we can, until we
|
|
|
|
** would block or there is an error/eof
|
|
|
|
*/
|
|
|
|
while(p->len > 0) {
|
|
|
|
int r = adb_write(s->fd, p->ptr, p->len);
|
|
|
|
if(r > 0) {
|
|
|
|
p->len -= r;
|
|
|
|
p->ptr += r;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if((r == 0) || (errno != EAGAIN)) {
|
|
|
|
D( "LS(%d): not ready, errno=%d: %s\n", s->id, errno, strerror(errno) );
|
|
|
|
s->close(s);
|
|
|
|
return 1; /* not ready (error) */
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(p->len == 0) {
|
|
|
|
put_apacket(p);
|
|
|
|
return 0; /* ready for more data */
|
|
|
|
}
|
|
|
|
|
|
|
|
enqueue:
|
|
|
|
p->next = 0;
|
|
|
|
if(s->pkt_first) {
|
|
|
|
s->pkt_last->next = p;
|
|
|
|
} else {
|
|
|
|
s->pkt_first = p;
|
|
|
|
}
|
|
|
|
s->pkt_last = p;
|
|
|
|
|
|
|
|
/* make sure we are notified when we can drain the queue */
|
|
|
|
fdevent_add(&s->fde, FDE_WRITE);
|
|
|
|
|
|
|
|
return 1; /* not ready (backlog) */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void local_socket_ready(asocket *s)
|
|
|
|
{
|
|
|
|
/* far side is ready for data, pay attention to
|
|
|
|
readable events */
|
|
|
|
fdevent_add(&s->fde, FDE_READ);
|
|
|
|
// D("LS(%d): ready()\n", s->id);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void local_socket_close(asocket *s)
|
|
|
|
{
|
|
|
|
adb_mutex_lock(&socket_list_lock);
|
|
|
|
local_socket_close_locked(s);
|
|
|
|
adb_mutex_unlock(&socket_list_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
// be sure to hold the socket list lock when calling this
|
|
|
|
static void local_socket_destroy(asocket *s)
|
|
|
|
{
|
|
|
|
apacket *p, *n;
|
2012-03-17 05:50:07 +08:00
|
|
|
int exit_on_close = s->exit_on_close;
|
|
|
|
|
2011-03-17 06:57:42 +08:00
|
|
|
D("LS(%d): destroying fde.fd=%d\n", s->id, s->fde.fd);
|
2009-03-04 11:32:55 +08:00
|
|
|
|
|
|
|
/* IMPORTANT: the remove closes the fd
|
|
|
|
** that belongs to this socket
|
|
|
|
*/
|
|
|
|
fdevent_remove(&s->fde);
|
|
|
|
|
|
|
|
/* dispose of any unwritten data */
|
|
|
|
for(p = s->pkt_first; p; p = n) {
|
|
|
|
D("LS(%d): discarding %d bytes\n", s->id, p->len);
|
|
|
|
n = p->next;
|
|
|
|
put_apacket(p);
|
|
|
|
}
|
|
|
|
remove_socket(s);
|
|
|
|
free(s);
|
2012-03-17 05:50:07 +08:00
|
|
|
|
|
|
|
if (exit_on_close) {
|
|
|
|
D("local_socket_destroy: exiting\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void local_socket_close_locked(asocket *s)
|
|
|
|
{
|
2011-03-17 06:57:42 +08:00
|
|
|
D("entered. LS(%d) fd=%d\n", s->id, s->fd);
|
2009-03-04 11:32:55 +08:00
|
|
|
if(s->peer) {
|
2011-03-17 06:57:42 +08:00
|
|
|
D("LS(%d): closing peer. peer->id=%d peer->fd=%d\n",
|
|
|
|
s->id, s->peer->id, s->peer->fd);
|
2013-12-13 21:09:44 +08:00
|
|
|
/* Note: it's important to call shutdown before disconnecting from
|
|
|
|
* the peer, this ensures that remote sockets can still get the id
|
|
|
|
* of the local socket they're connected to, to send a CLOSE()
|
|
|
|
* protocol event. */
|
|
|
|
if (s->peer->shutdown)
|
|
|
|
s->peer->shutdown(s->peer);
|
2009-03-04 11:32:55 +08:00
|
|
|
s->peer->peer = 0;
|
|
|
|
// tweak to avoid deadlock
|
2011-05-14 02:24:55 +08:00
|
|
|
if (s->peer->close == local_socket_close) {
|
2009-03-04 11:32:55 +08:00
|
|
|
local_socket_close_locked(s->peer);
|
2011-05-14 02:24:55 +08:00
|
|
|
} else {
|
2009-03-04 11:32:55 +08:00
|
|
|
s->peer->close(s->peer);
|
2011-05-14 02:24:55 +08:00
|
|
|
}
|
|
|
|
s->peer = 0;
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If we are already closing, or if there are no
|
|
|
|
** pending packets, destroy immediately
|
|
|
|
*/
|
|
|
|
if (s->closing || s->pkt_first == NULL) {
|
|
|
|
int id = s->id;
|
|
|
|
local_socket_destroy(s);
|
|
|
|
D("LS(%d): closed\n", id);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* otherwise, put on the closing list
|
|
|
|
*/
|
|
|
|
D("LS(%d): closing\n", s->id);
|
|
|
|
s->closing = 1;
|
|
|
|
fdevent_del(&s->fde, FDE_READ);
|
|
|
|
remove_socket(s);
|
2011-03-17 06:57:42 +08:00
|
|
|
D("LS(%d): put on socket_closing_list fd=%d\n", s->id, s->fd);
|
2009-03-04 11:32:55 +08:00
|
|
|
insert_local_socket(s, &local_socket_closing_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void local_socket_event_func(int fd, unsigned ev, void *_s)
|
|
|
|
{
|
|
|
|
asocket *s = _s;
|
|
|
|
|
2011-03-17 06:57:42 +08:00
|
|
|
D("LS(%d): event_func(fd=%d(==%d), ev=%04x)\n", s->id, s->fd, fd, ev);
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
/* put the FDE_WRITE processing before the FDE_READ
|
|
|
|
** in order to simplify the code.
|
|
|
|
*/
|
|
|
|
if(ev & FDE_WRITE){
|
|
|
|
apacket *p;
|
|
|
|
|
|
|
|
while((p = s->pkt_first) != 0) {
|
|
|
|
while(p->len > 0) {
|
|
|
|
int r = adb_write(fd, p->ptr, p->len);
|
|
|
|
if(r > 0) {
|
|
|
|
p->ptr += r;
|
|
|
|
p->len -= r;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if(r < 0) {
|
|
|
|
/* returning here is ok because FDE_READ will
|
|
|
|
** be processed in the next iteration loop
|
|
|
|
*/
|
|
|
|
if(errno == EAGAIN) return;
|
|
|
|
if(errno == EINTR) continue;
|
|
|
|
}
|
2011-06-11 02:38:37 +08:00
|
|
|
D(" closing after write because r=%d and errno is %d\n", r, errno);
|
2009-03-04 11:32:55 +08:00
|
|
|
s->close(s);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(p->len == 0) {
|
|
|
|
s->pkt_first = p->next;
|
|
|
|
if(s->pkt_first == 0) s->pkt_last = 0;
|
|
|
|
put_apacket(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if we sent the last packet of a closing socket,
|
|
|
|
** we can now destroy it.
|
|
|
|
*/
|
|
|
|
if (s->closing) {
|
2011-06-11 02:38:37 +08:00
|
|
|
D(" closing because 'closing' is set after write\n");
|
2009-03-04 11:32:55 +08:00
|
|
|
s->close(s);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* no more packets queued, so we can ignore
|
|
|
|
** writable events again and tell our peer
|
|
|
|
** to resume writing
|
|
|
|
*/
|
|
|
|
fdevent_del(&s->fde, FDE_WRITE);
|
|
|
|
s->peer->ready(s->peer);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if(ev & FDE_READ){
|
|
|
|
apacket *p = get_apacket();
|
|
|
|
unsigned char *x = p->data;
|
|
|
|
size_t avail = MAX_PAYLOAD;
|
|
|
|
int r;
|
|
|
|
int is_eof = 0;
|
|
|
|
|
|
|
|
while(avail > 0) {
|
|
|
|
r = adb_read(fd, x, avail);
|
2014-01-17 02:53:11 +08:00
|
|
|
D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%zu\n", s->id, s->fd, r, r<0?errno:0, avail);
|
2009-03-04 11:32:55 +08:00
|
|
|
if(r > 0) {
|
|
|
|
avail -= r;
|
|
|
|
x += r;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if(r < 0) {
|
|
|
|
if(errno == EAGAIN) break;
|
|
|
|
if(errno == EINTR) continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* r = 0 or unhandled error */
|
|
|
|
is_eof = 1;
|
|
|
|
break;
|
|
|
|
}
|
2011-03-17 06:57:42 +08:00
|
|
|
D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d\n",
|
|
|
|
s->id, s->fd, r, is_eof, s->fde.force_eof);
|
2009-03-04 11:32:55 +08:00
|
|
|
if((avail == MAX_PAYLOAD) || (s->peer == 0)) {
|
|
|
|
put_apacket(p);
|
|
|
|
} else {
|
|
|
|
p->len = MAX_PAYLOAD - avail;
|
|
|
|
|
|
|
|
r = s->peer->enqueue(s->peer, p);
|
2011-03-17 06:57:42 +08:00
|
|
|
D("LS(%d): fd=%d post peer->enqueue(). r=%d\n", s->id, s->fd, r);
|
2009-03-04 11:32:55 +08:00
|
|
|
|
|
|
|
if(r < 0) {
|
|
|
|
/* error return means they closed us as a side-effect
|
|
|
|
** and we must return immediately.
|
|
|
|
**
|
|
|
|
** note that if we still have buffered packets, the
|
|
|
|
** socket will be placed on the closing socket list.
|
|
|
|
** this handler function will be called again
|
|
|
|
** to process FDE_WRITE events.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(r > 0) {
|
|
|
|
/* if the remote cannot accept further events,
|
|
|
|
** we disable notification of READs. They'll
|
|
|
|
** be enabled again when we get a call to ready()
|
|
|
|
*/
|
|
|
|
fdevent_del(&s->fde, FDE_READ);
|
|
|
|
}
|
|
|
|
}
|
2011-04-13 13:01:58 +08:00
|
|
|
/* Don't allow a forced eof if data is still there */
|
|
|
|
if((s->fde.force_eof && !r) || is_eof) {
|
2011-06-11 02:38:37 +08:00
|
|
|
D(" closing because is_eof=%d r=%d s->fde.force_eof=%d\n", is_eof, r, s->fde.force_eof);
|
2009-03-04 11:32:55 +08:00
|
|
|
s->close(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(ev & FDE_ERROR){
|
|
|
|
/* this should be caught be the next read or write
|
|
|
|
** catching it here means we may skip the last few
|
|
|
|
** bytes of readable data.
|
|
|
|
*/
|
|
|
|
// s->close(s);
|
2011-03-17 06:57:42 +08:00
|
|
|
D("LS(%d): FDE_ERROR (fd=%d)\n", s->id, s->fd);
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
asocket *create_local_socket(int fd)
|
|
|
|
{
|
|
|
|
asocket *s = calloc(1, sizeof(asocket));
|
2010-06-11 07:48:19 +08:00
|
|
|
if (s == NULL) fatal("cannot allocate socket");
|
2009-03-04 11:32:55 +08:00
|
|
|
s->fd = fd;
|
|
|
|
s->enqueue = local_socket_enqueue;
|
|
|
|
s->ready = local_socket_ready;
|
2013-12-13 21:09:44 +08:00
|
|
|
s->shutdown = NULL;
|
2009-03-04 11:32:55 +08:00
|
|
|
s->close = local_socket_close;
|
2011-03-17 06:57:42 +08:00
|
|
|
install_local_socket(s);
|
2009-03-04 11:32:55 +08:00
|
|
|
|
|
|
|
fdevent_install(&s->fde, fd, local_socket_event_func, s);
|
|
|
|
/* fdevent_add(&s->fde, FDE_ERROR); */
|
|
|
|
//fprintf(stderr, "Created local socket in create_local_socket \n");
|
|
|
|
D("LS(%d): created (fd=%d)\n", s->id, s->fd);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
asocket *create_local_service_socket(const char *name)
|
|
|
|
{
|
|
|
|
asocket *s;
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
#if !ADB_HOST
|
|
|
|
if (!strcmp(name,"jdwp")) {
|
|
|
|
return create_jdwp_service_socket();
|
|
|
|
}
|
|
|
|
if (!strcmp(name,"track-jdwp")) {
|
|
|
|
return create_jdwp_tracker_service_socket();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
fd = service_to_fd(name);
|
|
|
|
if(fd < 0) return 0;
|
|
|
|
|
|
|
|
s = create_local_socket(fd);
|
2011-03-17 06:57:42 +08:00
|
|
|
D("LS(%d): bound to '%s' via %d\n", s->id, name, fd);
|
2012-03-17 05:50:07 +08:00
|
|
|
|
2012-03-31 04:19:11 +08:00
|
|
|
#if !ADB_HOST
|
2012-06-13 03:12:18 +08:00
|
|
|
if ((!strncmp(name, "root:", 5) && getuid() != 0)
|
|
|
|
|| !strncmp(name, "usb:", 4)
|
|
|
|
|| !strncmp(name, "tcpip:", 6)) {
|
2012-03-17 05:50:07 +08:00
|
|
|
D("LS(%d): enabling exit_on_close\n", s->id);
|
|
|
|
s->exit_on_close = 1;
|
|
|
|
}
|
2012-03-31 04:19:11 +08:00
|
|
|
#endif
|
2012-03-17 05:50:07 +08:00
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if ADB_HOST
|
|
|
|
static asocket *create_host_service_socket(const char *name, const char* serial)
|
|
|
|
{
|
|
|
|
asocket *s;
|
|
|
|
|
|
|
|
s = host_service_to_socket(name, serial);
|
|
|
|
|
|
|
|
if (s != NULL) {
|
|
|
|
D("LS(%d) bound to '%s'\n", s->id, name);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
#endif /* ADB_HOST */
|
|
|
|
|
|
|
|
/* a Remote socket is used to send/receive data to/from a given transport object
|
|
|
|
** it needs to be closed when the transport is forcibly destroyed by the user
|
|
|
|
*/
|
|
|
|
typedef struct aremotesocket {
|
|
|
|
asocket socket;
|
|
|
|
adisconnect disconnect;
|
|
|
|
} aremotesocket;
|
|
|
|
|
|
|
|
static int remote_socket_enqueue(asocket *s, apacket *p)
|
|
|
|
{
|
2011-03-17 06:57:42 +08:00
|
|
|
D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d\n",
|
|
|
|
s->id, s->fd, s->peer->fd);
|
2009-03-04 11:32:55 +08:00
|
|
|
p->msg.command = A_WRTE;
|
|
|
|
p->msg.arg0 = s->peer->id;
|
|
|
|
p->msg.arg1 = s->id;
|
|
|
|
p->msg.data_length = p->len;
|
|
|
|
send_packet(p, s->transport);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void remote_socket_ready(asocket *s)
|
|
|
|
{
|
2011-03-17 06:57:42 +08:00
|
|
|
D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d\n",
|
|
|
|
s->id, s->fd, s->peer->fd);
|
2009-03-04 11:32:55 +08:00
|
|
|
apacket *p = get_apacket();
|
|
|
|
p->msg.command = A_OKAY;
|
|
|
|
p->msg.arg0 = s->peer->id;
|
|
|
|
p->msg.arg1 = s->id;
|
|
|
|
send_packet(p, s->transport);
|
|
|
|
}
|
|
|
|
|
2013-12-13 21:09:44 +08:00
|
|
|
static void remote_socket_shutdown(asocket *s)
|
2009-03-04 11:32:55 +08:00
|
|
|
{
|
2013-12-13 21:09:44 +08:00
|
|
|
D("entered remote_socket_shutdown RS(%d) CLOSE fd=%d peer->fd=%d\n",
|
2011-03-17 06:57:42 +08:00
|
|
|
s->id, s->fd, s->peer?s->peer->fd:-1);
|
2009-03-04 11:32:55 +08:00
|
|
|
apacket *p = get_apacket();
|
|
|
|
p->msg.command = A_CLSE;
|
|
|
|
if(s->peer) {
|
|
|
|
p->msg.arg0 = s->peer->id;
|
2013-12-13 21:09:44 +08:00
|
|
|
}
|
|
|
|
p->msg.arg1 = s->id;
|
|
|
|
send_packet(p, s->transport);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void remote_socket_close(asocket *s)
|
|
|
|
{
|
|
|
|
if (s->peer) {
|
2009-03-04 11:32:55 +08:00
|
|
|
s->peer->peer = 0;
|
2011-03-17 06:57:42 +08:00
|
|
|
D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d\n",
|
|
|
|
s->id, s->peer->id, s->peer->fd);
|
2009-03-04 11:32:55 +08:00
|
|
|
s->peer->close(s->peer);
|
|
|
|
}
|
2013-12-13 21:09:44 +08:00
|
|
|
D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d\n",
|
|
|
|
s->id, s->fd, s->peer?s->peer->fd:-1);
|
2009-03-04 11:32:55 +08:00
|
|
|
D("RS(%d): closed\n", s->id);
|
|
|
|
remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
|
|
|
|
free(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void remote_socket_disconnect(void* _s, atransport* t)
|
|
|
|
{
|
|
|
|
asocket* s = _s;
|
|
|
|
asocket* peer = s->peer;
|
|
|
|
|
|
|
|
D("remote_socket_disconnect RS(%d)\n", s->id);
|
|
|
|
if (peer) {
|
|
|
|
peer->peer = NULL;
|
|
|
|
peer->close(peer);
|
|
|
|
}
|
|
|
|
remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
|
|
|
|
free(s);
|
|
|
|
}
|
|
|
|
|
2013-12-13 21:09:44 +08:00
|
|
|
/* Create an asocket to exchange packets with a remote service through transport
|
|
|
|
|t|. Where |id| is the socket id of the corresponding service on the other
|
|
|
|
side of the transport (it is allocated by the remote side and _cannot_ be 0).
|
|
|
|
Returns a new non-NULL asocket handle. */
|
2009-03-04 11:32:55 +08:00
|
|
|
asocket *create_remote_socket(unsigned id, atransport *t)
|
|
|
|
{
|
2013-12-13 21:09:44 +08:00
|
|
|
asocket* s;
|
|
|
|
adisconnect* dis;
|
|
|
|
|
|
|
|
if (id == 0) fatal("invalid remote socket id (0)");
|
|
|
|
s = calloc(1, sizeof(aremotesocket));
|
|
|
|
dis = &((aremotesocket*)s)->disconnect;
|
2009-03-04 11:32:55 +08:00
|
|
|
|
2010-06-11 07:48:19 +08:00
|
|
|
if (s == NULL) fatal("cannot allocate socket");
|
2009-03-04 11:32:55 +08:00
|
|
|
s->id = id;
|
|
|
|
s->enqueue = remote_socket_enqueue;
|
|
|
|
s->ready = remote_socket_ready;
|
2013-12-13 21:09:44 +08:00
|
|
|
s->shutdown = remote_socket_shutdown;
|
2009-03-04 11:32:55 +08:00
|
|
|
s->close = remote_socket_close;
|
|
|
|
s->transport = t;
|
|
|
|
|
|
|
|
dis->func = remote_socket_disconnect;
|
|
|
|
dis->opaque = s;
|
|
|
|
add_transport_disconnect( t, dis );
|
|
|
|
D("RS(%d): created\n", s->id);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
void connect_to_remote(asocket *s, const char *destination)
|
|
|
|
{
|
2011-03-17 06:57:42 +08:00
|
|
|
D("Connect_to_remote call RS(%d) fd=%d\n", s->id, s->fd);
|
2009-03-04 11:32:55 +08:00
|
|
|
apacket *p = get_apacket();
|
|
|
|
int len = strlen(destination) + 1;
|
|
|
|
|
|
|
|
if(len > (MAX_PAYLOAD-1)) {
|
|
|
|
fatal("destination oversized");
|
|
|
|
}
|
|
|
|
|
|
|
|
D("LS(%d): connect('%s')\n", s->id, destination);
|
|
|
|
p->msg.command = A_OPEN;
|
|
|
|
p->msg.arg0 = s->id;
|
|
|
|
p->msg.data_length = len;
|
|
|
|
strcpy((char*) p->data, destination);
|
|
|
|
send_packet(p, s->transport);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* this is used by magic sockets to rig local sockets to
|
|
|
|
send the go-ahead message when they connect */
|
|
|
|
static void local_socket_ready_notify(asocket *s)
|
|
|
|
{
|
|
|
|
s->ready = local_socket_ready;
|
2013-12-13 21:09:44 +08:00
|
|
|
s->shutdown = NULL;
|
2009-03-04 11:32:55 +08:00
|
|
|
s->close = local_socket_close;
|
|
|
|
adb_write(s->fd, "OKAY", 4);
|
|
|
|
s->ready(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* this is used by magic sockets to rig local sockets to
|
|
|
|
send the failure message if they are closed before
|
|
|
|
connected (to avoid closing them without a status message) */
|
|
|
|
static void local_socket_close_notify(asocket *s)
|
|
|
|
{
|
|
|
|
s->ready = local_socket_ready;
|
2013-12-13 21:09:44 +08:00
|
|
|
s->shutdown = NULL;
|
2009-03-04 11:32:55 +08:00
|
|
|
s->close = local_socket_close;
|
|
|
|
sendfailmsg(s->fd, "closed");
|
|
|
|
s->close(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned unhex(unsigned char *s, int len)
|
|
|
|
{
|
|
|
|
unsigned n = 0, c;
|
|
|
|
|
|
|
|
while(len-- > 0) {
|
|
|
|
switch((c = *s++)) {
|
|
|
|
case '0': case '1': case '2':
|
|
|
|
case '3': case '4': case '5':
|
|
|
|
case '6': case '7': case '8':
|
|
|
|
case '9':
|
|
|
|
c -= '0';
|
|
|
|
break;
|
|
|
|
case 'a': case 'b': case 'c':
|
|
|
|
case 'd': case 'e': case 'f':
|
|
|
|
c = c - 'a' + 10;
|
|
|
|
break;
|
|
|
|
case 'A': case 'B': case 'C':
|
|
|
|
case 'D': case 'E': case 'F':
|
|
|
|
c = c - 'A' + 10;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0xffffffff;
|
|
|
|
}
|
|
|
|
|
|
|
|
n = (n << 4) | c;
|
|
|
|
}
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
adb: Generalizing -s to take qualifiers.
Prior to this change, -s could take either a serial number or a
device path (e.g. "-s 01498B1F02015015" or "-s usb:1-4.2"). This
change extends -s to also allow product, model or device names
(e.g. "-s product:mysid"). These new qualifiers will only be
available on devices that are running an adb daemon that provides
properties in the connect message per Change-Id:
I09200decde4facb8fc9b4056fdae910155f2bcb9
The product, model and device are derived from the
ro.product.name, ro.product.model and ro.product.device
properties respectively. They are prefixed with "product:",
"model:" or "device:" as appropriate. In addition, any
non-alphanumerics in the model are changed to underscores.
If the -s parameter matches multiple devices, the result will be
the same as when multiple devices are connected but no -d, -e or
-s option is specified. In general, this means the user will get
"error: more than one device". However for get-state,
get-devpath and get-serialno, they will get "unknown".
The format of "devices -l" was changed to list all of the
qualifiers that are available. The following example output
(with the last digits of the serial numbers replaced with X's) is
with a Galaxy Prime with an older adb daemon and another Galaxy
Prime and Galaxy S both with the enhanced adb daemons:
List of devices attached
016B75D60A0060XX device usb:2-5 product:mysid model:Galaxy_Nexus device:toro
3731B535FAC200XX device usb:1-4.2 product:soju model:Nexus_S device:crespo
01498B1F020150XX device usb:1-4.1
Note that the serial number and state are now column oriented
instead of tab delimited. After the serial number and state, all
qualifiers are listed with each preceded by a space. The output
of the original devices command (without -l) is unchanged.
Change-Id: Iceeb2789874effc25a630d514a375d6f1889dc56
Signed-off-by: Scott Anderson <saa@android.com>
2012-05-31 09:11:27 +08:00
|
|
|
#define PREFIX(str) { str, sizeof(str) - 1 }
|
|
|
|
static const struct prefix_struct {
|
|
|
|
const char *str;
|
|
|
|
const size_t len;
|
|
|
|
} prefixes[] = {
|
|
|
|
PREFIX("usb:"),
|
|
|
|
PREFIX("product:"),
|
|
|
|
PREFIX("model:"),
|
|
|
|
PREFIX("device:"),
|
|
|
|
};
|
|
|
|
static const int num_prefixes = (sizeof(prefixes) / sizeof(prefixes[0]));
|
|
|
|
|
2011-03-16 16:43:56 +08:00
|
|
|
/* skip_host_serial return the position in a string
|
|
|
|
skipping over the 'serial' parameter in the ADB protocol,
|
|
|
|
where parameter string may be a host:port string containing
|
|
|
|
the protocol delimiter (colon). */
|
|
|
|
char *skip_host_serial(char *service) {
|
|
|
|
char *first_colon, *serial_end;
|
adb: Generalizing -s to take qualifiers.
Prior to this change, -s could take either a serial number or a
device path (e.g. "-s 01498B1F02015015" or "-s usb:1-4.2"). This
change extends -s to also allow product, model or device names
(e.g. "-s product:mysid"). These new qualifiers will only be
available on devices that are running an adb daemon that provides
properties in the connect message per Change-Id:
I09200decde4facb8fc9b4056fdae910155f2bcb9
The product, model and device are derived from the
ro.product.name, ro.product.model and ro.product.device
properties respectively. They are prefixed with "product:",
"model:" or "device:" as appropriate. In addition, any
non-alphanumerics in the model are changed to underscores.
If the -s parameter matches multiple devices, the result will be
the same as when multiple devices are connected but no -d, -e or
-s option is specified. In general, this means the user will get
"error: more than one device". However for get-state,
get-devpath and get-serialno, they will get "unknown".
The format of "devices -l" was changed to list all of the
qualifiers that are available. The following example output
(with the last digits of the serial numbers replaced with X's) is
with a Galaxy Prime with an older adb daemon and another Galaxy
Prime and Galaxy S both with the enhanced adb daemons:
List of devices attached
016B75D60A0060XX device usb:2-5 product:mysid model:Galaxy_Nexus device:toro
3731B535FAC200XX device usb:1-4.2 product:soju model:Nexus_S device:crespo
01498B1F020150XX device usb:1-4.1
Note that the serial number and state are now column oriented
instead of tab delimited. After the serial number and state, all
qualifiers are listed with each preceded by a space. The output
of the original devices command (without -l) is unchanged.
Change-Id: Iceeb2789874effc25a630d514a375d6f1889dc56
Signed-off-by: Scott Anderson <saa@android.com>
2012-05-31 09:11:27 +08:00
|
|
|
int i;
|
2011-03-16 16:43:56 +08:00
|
|
|
|
adb: Generalizing -s to take qualifiers.
Prior to this change, -s could take either a serial number or a
device path (e.g. "-s 01498B1F02015015" or "-s usb:1-4.2"). This
change extends -s to also allow product, model or device names
(e.g. "-s product:mysid"). These new qualifiers will only be
available on devices that are running an adb daemon that provides
properties in the connect message per Change-Id:
I09200decde4facb8fc9b4056fdae910155f2bcb9
The product, model and device are derived from the
ro.product.name, ro.product.model and ro.product.device
properties respectively. They are prefixed with "product:",
"model:" or "device:" as appropriate. In addition, any
non-alphanumerics in the model are changed to underscores.
If the -s parameter matches multiple devices, the result will be
the same as when multiple devices are connected but no -d, -e or
-s option is specified. In general, this means the user will get
"error: more than one device". However for get-state,
get-devpath and get-serialno, they will get "unknown".
The format of "devices -l" was changed to list all of the
qualifiers that are available. The following example output
(with the last digits of the serial numbers replaced with X's) is
with a Galaxy Prime with an older adb daemon and another Galaxy
Prime and Galaxy S both with the enhanced adb daemons:
List of devices attached
016B75D60A0060XX device usb:2-5 product:mysid model:Galaxy_Nexus device:toro
3731B535FAC200XX device usb:1-4.2 product:soju model:Nexus_S device:crespo
01498B1F020150XX device usb:1-4.1
Note that the serial number and state are now column oriented
instead of tab delimited. After the serial number and state, all
qualifiers are listed with each preceded by a space. The output
of the original devices command (without -l) is unchanged.
Change-Id: Iceeb2789874effc25a630d514a375d6f1889dc56
Signed-off-by: Scott Anderson <saa@android.com>
2012-05-31 09:11:27 +08:00
|
|
|
for (i = 0; i < num_prefixes; i++) {
|
|
|
|
if (!strncmp(service, prefixes[i].str, prefixes[i].len))
|
|
|
|
return strchr(service + prefixes[i].len, ':');
|
2012-06-01 03:04:23 +08:00
|
|
|
}
|
|
|
|
|
2011-03-16 16:43:56 +08:00
|
|
|
first_colon = strchr(service, ':');
|
|
|
|
if (!first_colon) {
|
|
|
|
/* No colon in service string. */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
serial_end = first_colon;
|
|
|
|
if (isdigit(serial_end[1])) {
|
|
|
|
serial_end++;
|
|
|
|
while ((*serial_end) && isdigit(*serial_end)) {
|
|
|
|
serial_end++;
|
|
|
|
}
|
|
|
|
if ((*serial_end) != ':') {
|
|
|
|
// Something other than numbers was found, reset the end.
|
|
|
|
serial_end = first_colon;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return serial_end;
|
|
|
|
}
|
|
|
|
|
2009-03-04 11:32:55 +08:00
|
|
|
static int smart_socket_enqueue(asocket *s, apacket *p)
|
|
|
|
{
|
|
|
|
unsigned len;
|
|
|
|
#if ADB_HOST
|
|
|
|
char *service = NULL;
|
|
|
|
char* serial = NULL;
|
|
|
|
transport_type ttype = kTransportAny;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
D("SS(%d): enqueue %d\n", s->id, p->len);
|
|
|
|
|
|
|
|
if(s->pkt_first == 0) {
|
|
|
|
s->pkt_first = p;
|
|
|
|
s->pkt_last = p;
|
|
|
|
} else {
|
|
|
|
if((s->pkt_first->len + p->len) > MAX_PAYLOAD) {
|
|
|
|
D("SS(%d): overflow\n", s->id);
|
|
|
|
put_apacket(p);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(s->pkt_first->data + s->pkt_first->len,
|
|
|
|
p->data, p->len);
|
|
|
|
s->pkt_first->len += p->len;
|
|
|
|
put_apacket(p);
|
|
|
|
|
|
|
|
p = s->pkt_first;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* don't bother if we can't decode the length */
|
|
|
|
if(p->len < 4) return 0;
|
|
|
|
|
|
|
|
len = unhex(p->data, 4);
|
|
|
|
if((len < 1) || (len > 1024)) {
|
|
|
|
D("SS(%d): bad size (%d)\n", s->id, len);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
D("SS(%d): len is %d\n", s->id, len );
|
|
|
|
/* can't do anything until we have the full header */
|
|
|
|
if((len + 4) > p->len) {
|
|
|
|
D("SS(%d): waiting for %d more bytes\n", s->id, len+4 - p->len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
p->data[len + 4] = 0;
|
|
|
|
|
|
|
|
D("SS(%d): '%s'\n", s->id, (char*) (p->data + 4));
|
|
|
|
|
|
|
|
#if ADB_HOST
|
|
|
|
service = (char *)p->data + 4;
|
|
|
|
if(!strncmp(service, "host-serial:", strlen("host-serial:"))) {
|
|
|
|
char* serial_end;
|
|
|
|
service += strlen("host-serial:");
|
|
|
|
|
2011-03-16 16:43:56 +08:00
|
|
|
// serial number should follow "host:" and could be a host:port string.
|
|
|
|
serial_end = skip_host_serial(service);
|
2009-03-04 11:32:55 +08:00
|
|
|
if (serial_end) {
|
|
|
|
*serial_end = 0; // terminate string
|
|
|
|
serial = service;
|
|
|
|
service = serial_end + 1;
|
|
|
|
}
|
|
|
|
} else if (!strncmp(service, "host-usb:", strlen("host-usb:"))) {
|
|
|
|
ttype = kTransportUsb;
|
|
|
|
service += strlen("host-usb:");
|
|
|
|
} else if (!strncmp(service, "host-local:", strlen("host-local:"))) {
|
|
|
|
ttype = kTransportLocal;
|
|
|
|
service += strlen("host-local:");
|
|
|
|
} else if (!strncmp(service, "host:", strlen("host:"))) {
|
|
|
|
ttype = kTransportAny;
|
|
|
|
service += strlen("host:");
|
|
|
|
} else {
|
|
|
|
service = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (service) {
|
|
|
|
asocket *s2;
|
|
|
|
|
|
|
|
/* some requests are handled immediately -- in that
|
|
|
|
** case the handle_host_request() routine has sent
|
|
|
|
** the OKAY or FAIL message and all we have to do
|
|
|
|
** is clean up.
|
|
|
|
*/
|
|
|
|
if(handle_host_request(service, ttype, serial, s->peer->fd, s) == 0) {
|
|
|
|
/* XXX fail message? */
|
|
|
|
D( "SS(%d): handled host service '%s'\n", s->id, service );
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (!strncmp(service, "transport", strlen("transport"))) {
|
|
|
|
D( "SS(%d): okay transport\n", s->id );
|
|
|
|
p->len = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* try to find a local service with this name.
|
|
|
|
** if no such service exists, we'll fail out
|
|
|
|
** and tear down here.
|
|
|
|
*/
|
|
|
|
s2 = create_host_service_socket(service, serial);
|
|
|
|
if(s2 == 0) {
|
|
|
|
D( "SS(%d): couldn't create host service '%s'\n", s->id, service );
|
|
|
|
sendfailmsg(s->peer->fd, "unknown host service");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we've connected to a local host service,
|
|
|
|
** so we make our peer back into a regular
|
|
|
|
** local socket and bind it to the new local
|
|
|
|
** service socket, acknowledge the successful
|
|
|
|
** connection, and close this smart socket now
|
|
|
|
** that its work is done.
|
|
|
|
*/
|
|
|
|
adb_write(s->peer->fd, "OKAY", 4);
|
|
|
|
|
|
|
|
s->peer->ready = local_socket_ready;
|
2013-12-13 21:09:44 +08:00
|
|
|
s->peer->shutdown = NULL;
|
2009-03-04 11:32:55 +08:00
|
|
|
s->peer->close = local_socket_close;
|
|
|
|
s->peer->peer = s2;
|
|
|
|
s2->peer = s->peer;
|
|
|
|
s->peer = 0;
|
|
|
|
D( "SS(%d): okay\n", s->id );
|
|
|
|
s->close(s);
|
|
|
|
|
|
|
|
/* initial state is "ready" */
|
|
|
|
s2->ready(s2);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else /* !ADB_HOST */
|
|
|
|
if (s->transport == NULL) {
|
|
|
|
char* error_string = "unknown failure";
|
|
|
|
s->transport = acquire_one_transport (CS_ANY,
|
|
|
|
kTransportAny, NULL, &error_string);
|
|
|
|
|
|
|
|
if (s->transport == NULL) {
|
|
|
|
sendfailmsg(s->peer->fd, error_string);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if(!(s->transport) || (s->transport->connection_state == CS_OFFLINE)) {
|
|
|
|
/* if there's no remote we fail the connection
|
|
|
|
** right here and terminate it
|
|
|
|
*/
|
|
|
|
sendfailmsg(s->peer->fd, "device offline (x)");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* instrument our peer to pass the success or fail
|
|
|
|
** message back once it connects or closes, then
|
|
|
|
** detach from it, request the connection, and
|
|
|
|
** tear down
|
|
|
|
*/
|
|
|
|
s->peer->ready = local_socket_ready_notify;
|
2013-12-13 21:09:44 +08:00
|
|
|
s->peer->shutdown = NULL;
|
2009-03-04 11:32:55 +08:00
|
|
|
s->peer->close = local_socket_close_notify;
|
|
|
|
s->peer->peer = 0;
|
|
|
|
/* give him our transport and upref it */
|
|
|
|
s->peer->transport = s->transport;
|
|
|
|
|
|
|
|
connect_to_remote(s->peer, (char*) (p->data + 4));
|
|
|
|
s->peer = 0;
|
|
|
|
s->close(s);
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
/* we're going to close our peer as a side-effect, so
|
|
|
|
** return -1 to signal that state to the local socket
|
|
|
|
** who is enqueueing against us
|
|
|
|
*/
|
|
|
|
s->close(s);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void smart_socket_ready(asocket *s)
|
|
|
|
{
|
|
|
|
D("SS(%d): ready\n", s->id);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void smart_socket_close(asocket *s)
|
|
|
|
{
|
|
|
|
D("SS(%d): closed\n", s->id);
|
|
|
|
if(s->pkt_first){
|
|
|
|
put_apacket(s->pkt_first);
|
|
|
|
}
|
|
|
|
if(s->peer) {
|
|
|
|
s->peer->peer = 0;
|
|
|
|
s->peer->close(s->peer);
|
2011-05-14 02:24:55 +08:00
|
|
|
s->peer = 0;
|
2009-03-04 11:32:55 +08:00
|
|
|
}
|
|
|
|
free(s);
|
|
|
|
}
|
|
|
|
|
2013-02-21 07:04:53 +08:00
|
|
|
static asocket *create_smart_socket(void)
|
2009-03-04 11:32:55 +08:00
|
|
|
{
|
|
|
|
D("Creating smart socket \n");
|
|
|
|
asocket *s = calloc(1, sizeof(asocket));
|
2010-06-11 07:48:19 +08:00
|
|
|
if (s == NULL) fatal("cannot allocate socket");
|
2009-03-04 11:32:55 +08:00
|
|
|
s->enqueue = smart_socket_enqueue;
|
|
|
|
s->ready = smart_socket_ready;
|
2013-12-13 21:09:44 +08:00
|
|
|
s->shutdown = NULL;
|
2009-03-04 11:32:55 +08:00
|
|
|
s->close = smart_socket_close;
|
|
|
|
|
2013-02-21 07:04:53 +08:00
|
|
|
D("SS(%d)\n", s->id);
|
2009-03-04 11:32:55 +08:00
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
void connect_to_smartsocket(asocket *s)
|
|
|
|
{
|
|
|
|
D("Connecting to smart socket \n");
|
2013-02-21 07:04:53 +08:00
|
|
|
asocket *ss = create_smart_socket();
|
2009-03-04 11:32:55 +08:00
|
|
|
s->peer = ss;
|
|
|
|
ss->peer = s;
|
|
|
|
s->ready(s);
|
|
|
|
}
|