int tcp_start_incoming_migration(const char *host_port)
{
SockAddress addr;
int s;
if (parse_host_port(&addr, host_port) < 0) {
fprintf(stderr, "invalid host/port combination: %s\n", host_port);
return -EINVAL;
}
s = socket_create_inet(SOCKET_STREAM);
if (s == -1)
return -socket_error();
socket_set_xreuseaddr(s);
if (socket_bind(s, &addr) == -1)
goto err;
if (socket_listen(s, 1) == -1)
goto err;
qemu_set_fd_handler2(s, NULL, tcp_accept_incoming_migration, NULL,
(void *)(unsigned long)s);
return 0;
err:
socket_close(s);
return -socket_error();
}
ProxyConnection*
http_connector_connect( HttpService* service,
SockAddress* address )
{
Connection* conn;
int s;
s = socket_create_inet( SOCKET_STREAM );
if (s < 0)
return NULL;
conn = qemu_mallocz(sizeof(*conn));
if (conn == NULL) {
socket_close(s);
return NULL;
}
proxy_connection_init( conn->root, s, address, service->root,
connection_free,
connection_select,
connection_poll );
if ( connection_init( conn ) < 0 ) {
connection_free( conn->root );
return NULL;
}
return conn->root;
}
MigrationState *tcp_start_outgoing_migration(const char *host_port,
int64_t bandwidth_limit,
int detach)
{
SockAddress addr;
FdMigrationState *s;
int ret;
if (parse_host_port(&addr, host_port) < 0)
return NULL;
s = g_malloc0(sizeof(*s));
s->get_error = socket_errno;
s->write = socket_write;
s->close = tcp_close;
s->mig_state.cancel = migrate_fd_cancel;
s->mig_state.get_status = migrate_fd_get_status;
s->mig_state.release = migrate_fd_release;
s->state = MIG_STATE_ACTIVE;
s->mon_resume = NULL;
s->bandwidth_limit = bandwidth_limit;
s->fd = socket_create_inet(SOCKET_STREAM);
if (s->fd == -1) {
g_free(s);
return NULL;
}
socket_set_nonblock(s->fd);
if (!detach)
migrate_fd_monitor_suspend(s);
do {
ret = socket_connect(s->fd, &addr);
if (ret == -1)
ret = -(s->get_error(s));
if (ret == -EINPROGRESS || ret == -EWOULDBLOCK || ret == -EAGAIN)
qemu_set_fd_handler2(s->fd, NULL, NULL, tcp_wait_for_connect, s);
} while (ret == -EINTR);
if (ret < 0 && ret != -EINPROGRESS && ret != -EWOULDBLOCK && ret != -EAGAIN) {
dprintf("connect failed\n");
socket_close(s->fd);
g_free(s);
return NULL;
} else if (ret >= 0)
migrate_fd_connect(s);
return &s->mig_state;
}
static void
coreconsole_init(CoreConsole* cc, const SockAddress* address, Looper* looper)
{
int fd = socket_create_inet(SOCKET_STREAM);
AsyncStatus status;
cc->port = sock_address_get_port(address);
cc->ok = 0;
loopIo_init(cc->io, looper, fd, coreconsole_io_func, cc);
if (fd >= 0) {
status = asyncConsoleConnector_connect(cc->connector, address, cc->io);
if (status == ASYNC_ERROR) {
cc->ok = 0;
}
}
}
/* 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("ASC %s: Unable to create socket: %d -> %s",
_asc_socket_string(connector), errno, strerror(errno));
return -1;
}
/* Prepare for async I/O on the connector. */
socket_set_nonblock(connector->fd);
T("ASC %s: Connector socket is opened with FD = %d",
_asc_socket_string(connector), connector->fd);
return 0;
}
calipso_socket_t * calipso_do_listen_sock(const char *naddr,
int16_t portn)
{
int sd = socket_create_inet(naddr, portn);
calipso_socket_t * socket = calipso_socket_alloc();
if (socket && sd != -1) {
calipso_socket_set_port(socket, portn);
calipso_socket_set_socketfd(socket, sd);
/* init listener event */
socket->event = cpo_event_alloc(EVENT_LISTENER);
socket->event->data = socket;
} else {
cpo_log_error(calipso->log,
"Can't create lisnten socket %s",
strerror(errno));
exit(-1);
}
return (socket);
}
