android/async-socket-connector.c - fp2-dev/platform/external/qemu - Gitiles

 /*
  * Copyright (C) 2011 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.
  */

 /*
  * Encapsulates exchange protocol between the emulator, and an Android device
  * that is connected to the host via USB. The communication is established over
  * a TCP port forwarding, enabled by ADB.
  */

 #include "qemu-common.h"
 #include "android/async-utils.h"
 #include "android/utils/debug.h"
 #include "android/async-socket-connector.h"
 #include "utils/panic.h"
 #include "iolooper.h"

 #define  E(...)    derror(__VA_ARGS__)
 #define  W(...)    dwarning(__VA_ARGS__)
 #define  D(...)    VERBOSE_PRINT(asconnector,__VA_ARGS__)
 #define  D_ACTIVE  VERBOSE_CHECK(asconnector)

 /********************************************************************************
  *                             Internals
  *******************************************************************************/

 struct AsyncSocketConnector {
     /* TCP address for the connection. */
     SockAddress     address;
     /* I/O looper for asynchronous I/O. */
     Looper*         looper;
     /* I/O port for asynchronous connection. */
     LoopIo          connector_io[1];
     /* Timer that is used to retry asynchronous connections. */
     LoopTimer       connector_timer[1];
     /* Asynchronous connector to the socket. */
     AsyncConnector  connector[1];
     /* Callback to invoke on connection / connection error. */
     asc_event_cb    on_connected_cb;
     /* An opaque parameter to pass to the connection callback. */
     void*           on_connected_cb_opaque;
     /* Retry timeout in milliseconds. */
     int             retry_to;
     /* Socket descriptor for the connection. */
     int             fd;
 };

 /* Asynchronous I/O looper callback invoked by the connector.
  * Param:
  *  opaque - AsyncSocketConnector instance.
  *  fd, events - Standard I/O callback parameters.
  */
 static void _on_async_socket_connector_io(void* opaque, int fd, unsigned events);

 /* Gets socket's address string. */
 AINLINED const char*
 _asc_socket_string(AsyncSocketConnector* connector)
 {
     return sock_address_to_string(&connector->address);
 }

 /* Destroys AsyncSocketConnector instance.
  * Param:
  *  connector - Initialized AsyncSocketConnector instance.
  */
 static void
 _async_socket_connector_free(AsyncSocketConnector* connector)
 {
     if (connector != NULL) {
         if (connector->fd >= 0) {
             socket_close(connector->fd);
         }

         if (connector->looper != NULL) {
             loopTimer_done(connector->connector_timer);
             looper_free(connector->looper);
         }

         sock_address_done(&connector->address);

         AFREE(connector);
     }
 }

 /* Opens connection socket.
  * Param:
  *  connector - Initialized AsyncSocketConnector instance.
  * Return:
  *  0 on success, or -1 on failure.
  */
 static int
 _async_socket_connector_open_socket(AsyncSocketConnector* connector)
 {
     /* Open socket. */
     connector->fd = socket_create_inet(SOCKET_STREAM);
     if (connector->fd < 0) {
         D("Unable to create connector socket for %s. Error: %s",
           _asc_socket_string(connector), strerror(errno));
         return -1;
     }

     /* Prepare for async I/O on the connector. */
     socket_set_nonblock(connector->fd);
     loopIo_init(connector->connector_io, connector->looper, connector->fd,
                 _on_async_socket_connector_io, connector);

     return 0;
 }

 /* Closes connection socket.
  * Param:
  *  connector - Initialized AsyncSocketConnector instance.
  * Return:
  *  0 on success, or -1 on failure.
  */
 static void
 _async_socket_connector_close_socket(AsyncSocketConnector* connector)
 {
     if (connector->fd >= 0) {
         socket_close(connector->fd);
         connector->fd = -1;
     }
 }

 /* Asynchronous connector (AsyncConnector instance) has completed connection
  *  attempt.
  *
  * NOTE: Upon exit from this routine AsyncSocketConnector instance might be
  * destroyed. So, once this routine is called, there must be no further
  * references to AsyncSocketConnector instance passed to this routine.
  * Param:
  *  connector - Initialized AsyncSocketConnector instance.
  *  status - Status of the connection attempt.
  */
 static void
 _on_async_socket_connector_connecting(AsyncSocketConnector* connector,
                                       AsyncStatus status)
 {
     ASCCbRes action;
     int do_retry = 0;

     switch (status) {
         case ASYNC_COMPLETE:
             loopIo_done(connector->connector_io);
             D("Socket %s is connected", _asc_socket_string(connector));
             /* Invoke "on connected" callback */
             action = connector->on_connected_cb(connector->on_connected_cb_opaque,
                                                 connector, ASC_CONNECTION_SUCCEEDED);
             if (action == ASC_CB_RETRY) {
                 do_retry = 1;
             } else if (action == ASC_CB_ABORT) {
                 _async_socket_connector_close_socket(connector);
             }
             break;

         case ASYNC_ERROR:
             loopIo_done(connector->connector_io);
             D("Error %d while connecting to socket %s: %s",
               errno, _asc_socket_string(connector), strerror(errno));
             /* Invoke "on connected" callback */
             action = connector->on_connected_cb(connector->on_connected_cb_opaque,
                                                 connector, ASC_CONNECTION_FAILED);
             if (action == ASC_CB_RETRY) {
                 do_retry = 1;
             } else if (action == ASC_CB_ABORT) {
                 _async_socket_connector_close_socket(connector);
             }
             break;

         case ASYNC_NEED_MORE:
             return;
     }

     if (do_retry) {
         D("Retrying connection to socket %s", _asc_socket_string(connector));
         loopTimer_startRelative(connector->connector_timer, connector->retry_to);
     } else {
         _async_socket_connector_free(connector);
     }
 }

 static void
 _on_async_socket_connector_io(void* opaque, int fd, unsigned events)
 {
     AsyncSocketConnector* const connector = (AsyncSocketConnector*)opaque;

     /* Complete socket connection. */
     const AsyncStatus status = asyncConnector_run(connector->connector);
     _on_async_socket_connector_connecting(connector, status);
 }

 /* Retry connection timer callback.
  * Param:
  *  opaque - AsyncSocketConnector instance.
  */
 static void
 _on_async_socket_connector_retry(void* opaque)
 {
     AsyncSocketConnector* const connector = (AsyncSocketConnector*)opaque;

     /* Invoke the callback to notify about a connection retry attempt. */
     const ASCCbRes action =
         connector->on_connected_cb(connector->on_connected_cb_opaque,
                                    connector, ASC_CONNECTION_RETRY);

     if (action == ASC_CB_RETRY) {
         AsyncStatus status;

         /* Close handle opened for the previous (failed) attempt. */
         _async_socket_connector_close_socket(connector);

         /* Retry connection attempt. */
         if (_async_socket_connector_open_socket(connector) == 0) {
             status = asyncConnector_init(connector->connector, &connector->address,
                                          connector->connector_io);
         } else {
             status = ASYNC_ERROR;
         }

         _on_async_socket_connector_connecting(connector, status);
     } else {
         _async_socket_connector_free(connector);
     }
 }

 /********************************************************************************
  *                       Async connector implementation
  *******************************************************************************/

 AsyncSocketConnector*
 async_socket_connector_new(const SockAddress* address,
                            int retry_to,
                            asc_event_cb cb,
                            void* cb_opaque)
 {
     AsyncSocketConnector* connector;

     if (cb == NULL) {
         W("No callback for AsyncSocketConnector for %s",
           sock_address_to_string(address));
         errno = EINVAL;
         return NULL;
     }

     ANEW0(connector);

     connector->fd = -1;
     connector->retry_to = retry_to;
     connector->on_connected_cb = cb;
     connector->on_connected_cb_opaque = cb_opaque;

     /* Copy socket address. */
     if (sock_address_get_family(address) == SOCKET_UNIX) {
         sock_address_init_unix(&connector->address, sock_address_get_path(address));
     } else {
         connector->address = *address;
     }

     /* Create a looper for asynchronous I/O. */
     connector->looper = looper_newCore();
     if (connector->looper != NULL) {
         /* Create a timer that will be used for connection retries. */
         loopTimer_init(connector->connector_timer, connector->looper,
                        _on_async_socket_connector_retry, connector);
     } else {
         E("Unable to create I/O looper for asynchronous connector to socket %s",
           _asc_socket_string(connector));
         _async_socket_connector_free(connector);
         return NULL;
     }

     return connector;
 }

 ASCConnectRes
 async_socket_connector_connect(AsyncSocketConnector* connector)
 {
     AsyncStatus status;

     if (_async_socket_connector_open_socket(connector) == 0) {
         status = asyncConnector_init(connector->connector, &connector->address,
                                      connector->connector_io);
     } else {
         status = ASYNC_ERROR;
     }

     _on_async_socket_connector_connecting(connector, status);

     switch (status) {
         case ASYNC_COMPLETE:
             return ASC_CONNECT_SUCCEEDED;

         case ASYNC_ERROR:
             return ASC_CONNECT_FAILED;

         case ASYNC_NEED_MORE:
         default:
             return ASC_CONNECT_IN_PROGRESS;
     }
 }

 int
 async_socket_connector_pull_fd(AsyncSocketConnector* connector)
 {
     const int fd = connector->fd;
     if (fd >= 0) {
         connector->fd = -1;
     }
     return fd;
 }
	/*
	* Copyright (C) 2011 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.
	*/

	/*
	* Encapsulates exchange protocol between the emulator, and an Android device
	* that is connected to the host via USB. The communication is established over
	* a TCP port forwarding, enabled by ADB.
	*/

	#include "qemu-common.h"
	#include "android/async-utils.h"
	#include "android/utils/debug.h"
	#include "android/async-socket-connector.h"
	#include "utils/panic.h"
	#include "iolooper.h"

	#define E(...) derror(__VA_ARGS__)
	#define W(...) dwarning(__VA_ARGS__)
	#define D(...) VERBOSE_PRINT(asconnector,__VA_ARGS__)
	#define D_ACTIVE VERBOSE_CHECK(asconnector)

	/********************************************************************************
	* Internals
	*******************************************************************************/

	struct AsyncSocketConnector {
	/* TCP address for the connection. */
	SockAddress address;
	/* I/O looper for asynchronous I/O. */
	Looper* looper;
	/* I/O port for asynchronous connection. */
	LoopIo connector_io[1];
	/* Timer that is used to retry asynchronous connections. */
	LoopTimer connector_timer[1];
	/* Asynchronous connector to the socket. */
	AsyncConnector connector[1];
	/* Callback to invoke on connection / connection error. */
	asc_event_cb on_connected_cb;
	/* An opaque parameter to pass to the connection callback. */
	void* on_connected_cb_opaque;
	/* Retry timeout in milliseconds. */
	int retry_to;
	/* Socket descriptor for the connection. */
	int fd;
	};

	/* Asynchronous I/O looper callback invoked by the connector.
	* Param:
	* opaque - AsyncSocketConnector instance.
	* fd, events - Standard I/O callback parameters.
	*/
	static void _on_async_socket_connector_io(void* opaque, int fd, unsigned events);

	/* Gets socket's address string. */
	AINLINED const char*
	_asc_socket_string(AsyncSocketConnector* connector)
	{
	return sock_address_to_string(&connector->address);
	}

	/* Destroys AsyncSocketConnector instance.
	* Param:
	* connector - Initialized AsyncSocketConnector instance.
	*/
	static void
	_async_socket_connector_free(AsyncSocketConnector* connector)
	{
	if (connector != NULL) {
	if (connector->fd >= 0) {
	socket_close(connector->fd);
	}

	if (connector->looper != NULL) {
	loopTimer_done(connector->connector_timer);
	looper_free(connector->looper);
	}

	sock_address_done(&connector->address);

	AFREE(connector);
	}
	}

	/* Opens connection socket.
	* Param:
	* connector - Initialized AsyncSocketConnector instance.
	* Return:
	* 0 on success, or -1 on failure.
	*/
	static int
	_async_socket_connector_open_socket(AsyncSocketConnector* connector)
	{
	/* Open socket. */
	connector->fd = socket_create_inet(SOCKET_STREAM);
	if (connector->fd < 0) {
	D("Unable to create connector socket for %s. Error: %s",
	_asc_socket_string(connector), strerror(errno));
	return -1;
	}

	/* Prepare for async I/O on the connector. */
	socket_set_nonblock(connector->fd);
	loopIo_init(connector->connector_io, connector->looper, connector->fd,
	_on_async_socket_connector_io, connector);

	return 0;
	}

	/* Closes connection socket.
	* Param:
	* connector - Initialized AsyncSocketConnector instance.
	* Return:
	* 0 on success, or -1 on failure.
	*/
	static void
	_async_socket_connector_close_socket(AsyncSocketConnector* connector)
	{
	if (connector->fd >= 0) {
	socket_close(connector->fd);
	connector->fd = -1;
	}
	}

	/* Asynchronous connector (AsyncConnector instance) has completed connection
	* attempt.
	*
	* NOTE: Upon exit from this routine AsyncSocketConnector instance might be
	* destroyed. So, once this routine is called, there must be no further
	* references to AsyncSocketConnector instance passed to this routine.
	* Param:
	* connector - Initialized AsyncSocketConnector instance.
	* status - Status of the connection attempt.
	*/
	static void
	_on_async_socket_connector_connecting(AsyncSocketConnector* connector,
	AsyncStatus status)
	{
	ASCCbRes action;
	int do_retry = 0;

	switch (status) {
	case ASYNC_COMPLETE:
	loopIo_done(connector->connector_io);
	D("Socket %s is connected", _asc_socket_string(connector));
	/* Invoke "on connected" callback */
	action = connector->on_connected_cb(connector->on_connected_cb_opaque,
	connector, ASC_CONNECTION_SUCCEEDED);
	if (action == ASC_CB_RETRY) {
	do_retry = 1;
	} else if (action == ASC_CB_ABORT) {
	_async_socket_connector_close_socket(connector);
	}
	break;

	case ASYNC_ERROR:
	loopIo_done(connector->connector_io);
	D("Error %d while connecting to socket %s: %s",
	errno, _asc_socket_string(connector), strerror(errno));
	/* Invoke "on connected" callback */
	action = connector->on_connected_cb(connector->on_connected_cb_opaque,
	connector, ASC_CONNECTION_FAILED);
	if (action == ASC_CB_RETRY) {
	do_retry = 1;
	} else if (action == ASC_CB_ABORT) {
	_async_socket_connector_close_socket(connector);
	}
	break;

	case ASYNC_NEED_MORE:
	return;
	}

	if (do_retry) {
	D("Retrying connection to socket %s", _asc_socket_string(connector));
	loopTimer_startRelative(connector->connector_timer, connector->retry_to);
	} else {
	_async_socket_connector_free(connector);
	}
	}

	static void
	_on_async_socket_connector_io(void* opaque, int fd, unsigned events)
	{
	AsyncSocketConnector* const connector = (AsyncSocketConnector*)opaque;

	/* Complete socket connection. */
	const AsyncStatus status = asyncConnector_run(connector->connector);
	_on_async_socket_connector_connecting(connector, status);
	}

	/* Retry connection timer callback.
	* Param:
	* opaque - AsyncSocketConnector instance.
	*/
	static void
	_on_async_socket_connector_retry(void* opaque)
	{
	AsyncSocketConnector* const connector = (AsyncSocketConnector*)opaque;

	/* Invoke the callback to notify about a connection retry attempt. */
	const ASCCbRes action =
	connector->on_connected_cb(connector->on_connected_cb_opaque,
	connector, ASC_CONNECTION_RETRY);

	if (action == ASC_CB_RETRY) {
	AsyncStatus status;

	/* Close handle opened for the previous (failed) attempt. */
	_async_socket_connector_close_socket(connector);

	/* Retry connection attempt. */
	if (_async_socket_connector_open_socket(connector) == 0) {
	status = asyncConnector_init(connector->connector, &connector->address,
	connector->connector_io);
	} else {
	status = ASYNC_ERROR;
	}

	_on_async_socket_connector_connecting(connector, status);
	} else {
	_async_socket_connector_free(connector);
	}
	}

	/********************************************************************************
	* Async connector implementation
	*******************************************************************************/

	AsyncSocketConnector*
	async_socket_connector_new(const SockAddress* address,
	int retry_to,
	asc_event_cb cb,
	void* cb_opaque)
	{
	AsyncSocketConnector* connector;

	if (cb == NULL) {
	W("No callback for AsyncSocketConnector for %s",
	sock_address_to_string(address));
	errno = EINVAL;
	return NULL;
	}

	ANEW0(connector);

	connector->fd = -1;
	connector->retry_to = retry_to;
	connector->on_connected_cb = cb;
	connector->on_connected_cb_opaque = cb_opaque;

	/* Copy socket address. */
	if (sock_address_get_family(address) == SOCKET_UNIX) {
	sock_address_init_unix(&connector->address, sock_address_get_path(address));
	} else {
	connector->address = *address;
	}

	/* Create a looper for asynchronous I/O. */
	connector->looper = looper_newCore();
	if (connector->looper != NULL) {
	/* Create a timer that will be used for connection retries. */
	loopTimer_init(connector->connector_timer, connector->looper,
	_on_async_socket_connector_retry, connector);
	} else {
	E("Unable to create I/O looper for asynchronous connector to socket %s",
	_asc_socket_string(connector));
	_async_socket_connector_free(connector);
	return NULL;
	}

	return connector;
	}

	ASCConnectRes
	async_socket_connector_connect(AsyncSocketConnector* connector)
	{
	AsyncStatus status;

	if (_async_socket_connector_open_socket(connector) == 0) {
	status = asyncConnector_init(connector->connector, &connector->address,
	connector->connector_io);
	} else {
	status = ASYNC_ERROR;
	}

	_on_async_socket_connector_connecting(connector, status);

	switch (status) {
	case ASYNC_COMPLETE:
	return ASC_CONNECT_SUCCEEDED;

	case ASYNC_ERROR:
	return ASC_CONNECT_FAILED;

	case ASYNC_NEED_MORE:
	default:
	return ASC_CONNECT_IN_PROGRESS;
	}
	}

	int
	async_socket_connector_pull_fd(AsyncSocketConnector* connector)
	{
	const int fd = connector->fd;
	if (fd >= 0) {
	connector->fd = -1;
	}
	return fd;
	}