/* vi:set ts=8 sts=4 sw=4 noet:

*

* VIM - Vi IMproved by Bram Moolenaar

*

* Do ":help uganda" in Vim to read copying and usage conditions.

* Do ":help credits" in Vim to see a list of people who contributed.

*/

/*

* Implements communication through a socket or any file handle.

*/

#include "vim.h"

#if defined(FEAT_JOB_CHANNEL)

// TRUE when netbeans is running with a GUI.

#ifdef FEAT_GUI

# define CH_HAS_GUI (gui.in_use || gui.starting)

#endif

// Note: when making changes here also adjust configure.ac.

#ifdef MSWIN

// WinSock API is separated from C API, thus we can't use read(), write(),

// errno...

# define SOCK_ERRNO errno = WSAGetLastError()

# undef ECONNREFUSED

# define ECONNREFUSED WSAECONNREFUSED

# undef EWOULDBLOCK

# define EWOULDBLOCK WSAEWOULDBLOCK

# undef EINPROGRESS

# define EINPROGRESS WSAEINPROGRESS

# ifdef EINTR

# undef EINTR

# endif

# define EINTR WSAEINTR

# define sock_write(sd, buf, len) send((SOCKET)sd, buf, len, 0)

# define sock_read(sd, buf, len) recv((SOCKET)sd, buf, len, 0)

# define sock_close(sd) closesocket((SOCKET)sd)

// Support for Unix-domain sockets was added in Windows SDK 17061.

# define UNIX_PATH_MAX 108

typedef struct sockaddr_un {

ADDRESS_FAMILY sun_family;

char sun_path[UNIX_PATH_MAX];

} SOCKADDR_UN, *PSOCKADDR_UN;

#else

# include <netdb.h>

# include <netinet/in.h>

# include <arpa/inet.h>

# include <sys/socket.h>

# include <sys/un.h>

# ifdef HAVE_LIBGEN_H

# include <libgen.h>

# endif

# define SOCK_ERRNO

# define sock_write(sd, buf, len) write(sd, buf, len)

# define sock_read(sd, buf, len) read(sd, buf, len)

# define sock_close(sd) close(sd)

# define fd_read(fd, buf, len) read(fd, buf, len)

# define fd_write(sd, buf, len) write(sd, buf, len)

# define fd_close(sd) close(sd)

#endif

static void channel_read(channel_T *channel, ch_part_T part, char *func);

static void channel_wait_any(long msec);

static ch_mode_T channel_get_mode(channel_T *channel, ch_part_T part);

static int channel_get_timeout(channel_T *channel, ch_part_T part);

static channel_T *channel_open_stdio(void);

static ch_part_T channel_part_send(channel_T *channel);

static ch_part_T channel_part_read(channel_T *channel);

#define FOR_ALL_CHANNELS(ch) \

for ((ch) = first_channel; (ch) != NULL; (ch) = (ch)->ch_next)

// Whether we are inside channel_parse_messages() or another situation where it

// is safe to invoke callbacks.

static int safe_to_invoke_callback = 0;

#ifdef MSWIN

static int

fd_read(sock_T fd, char *buf, size_t len)

{

HANDLE h = (HANDLE)fd;

DWORD nread;

if (!ReadFile(h, buf, (DWORD)len, &nread, NULL))

return -1;

return (int)nread;

}

static int

fd_write(sock_T fd, char *buf, size_t len)

{

size_t todo = len;

HANDLE h = (HANDLE)fd;

DWORD nwrite, size, done = 0;

OVERLAPPED ov;

while (todo > 0)

{

if (todo > MAX_NAMED_PIPE_SIZE)

size = MAX_NAMED_PIPE_SIZE;

else

size = (DWORD)todo;

// If the pipe overflows while the job does not read the data,

// WriteFile() will block forever. This abandons the write.

CLEAR_FIELD(ov);

nwrite = 0;

if (!WriteFile(h, buf + done, size, &nwrite, &ov))

{

DWORD err = GetLastError();

if (err != ERROR_IO_PENDING)

return -1;

if (!GetOverlappedResult(h, &ov, &nwrite, FALSE))

return -1;

FlushFileBuffers(h);

}

else if (nwrite == 0)

// WriteFile() returns TRUE but did not write anything. This causes

// a hang, so bail out.

break;

todo -= nwrite;

done += nwrite;

}

return (int)done;

}

static void

fd_close(sock_T fd)

{

HANDLE h = (HANDLE)fd;

CloseHandle(h);

}

#endif

#ifdef MSWIN

# undef PERROR

# define PERROR(msg) (void)semsg("%s: %s", msg, strerror_win32(errno))

static char *

strerror_win32(int eno)

{

static LPVOID msgbuf = NULL;

char_u *ptr;

if (msgbuf)

{

LocalFree(msgbuf);

msgbuf = NULL;

}

FormatMessage(

FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM |

FORMAT_MESSAGE_IGNORE_INSERTS,

NULL,

eno,

MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),

(LPTSTR) &msgbuf,

0,

NULL);

if (msgbuf != NULL)

// chomp \r or \n

for (ptr = (char_u *)msgbuf; *ptr; ptr++)

switch (*ptr)

{

case '\r':

STRMOVE(ptr, ptr + 1);

ptr--;

break;

case '\n':

if (*(ptr + 1) == '\0')

*ptr = '\0';

else

*ptr = ' ';

break;

}

return msgbuf;

}

#endif

/*

* The list of all allocated channels.

*/

static channel_T *first_channel = NULL;

static int next_ch_id = 0;

/*

* Allocate a new channel. The refcount is set to 1.

* The channel isn't actually used until it is opened.

* Returns NULL if out of memory.

*/

channel_T *

add_channel(void)

{

ch_part_T part;

channel_T *channel = ALLOC_CLEAR_ONE(channel_T);

if (channel == NULL)

return NULL;

channel->ch_id = next_ch_id++;

ch_log(channel, "Created channel");

for (part = PART_SOCK; part < PART_COUNT; ++part)

{

channel->ch_part[part].ch_fd = INVALID_FD;

#ifdef FEAT_GUI_X11

channel->ch_part[part].ch_inputHandler = (XtInputId)NULL;

#endif

#ifdef FEAT_GUI_GTK

channel->ch_part[part].ch_inputHandler = 0;

#endif

#ifdef FEAT_GUI_MACVIM

channel->ch_part[part].ch_inputHandler = 0;

#endif

channel->ch_part[part].ch_timeout = 2000;

}

if (first_channel != NULL)

{

first_channel->ch_prev = channel;

channel->ch_next = first_channel;

}

first_channel = channel;

channel->ch_refcount = 1;

return channel;

}

int

has_any_channel(void)

{

return first_channel != NULL;

}

/*

* Called when the refcount of a channel is zero.

* Return TRUE if "channel" has a callback and the associated job wasn't

* killed.

*/

int

channel_still_useful(channel_T *channel)

{

int has_sock_msg;

int has_out_msg;

int has_err_msg;

// If the job was killed the channel is not expected to work anymore.

if (channel->ch_job_killed && channel->ch_job == NULL)

return FALSE;

// If there is a close callback it may still need to be invoked.

if (channel->ch_close_cb.cb_name != NULL)

return TRUE;

// If reading from or a buffer it's still useful.

if (channel->ch_part[PART_IN].ch_bufref.br_buf != NULL)

return TRUE;

// If there is no callback then nobody can get readahead. If the fd is

// closed and there is no readahead then the callback won't be called.

has_sock_msg = channel->ch_part[PART_SOCK].ch_fd != INVALID_FD

|| channel->ch_part[PART_SOCK].ch_head.rq_next != NULL

|| channel->ch_part[PART_SOCK].ch_json_head.jq_next != NULL;

has_out_msg = channel->ch_part[PART_OUT].ch_fd != INVALID_FD

|| channel->ch_part[PART_OUT].ch_head.rq_next != NULL

|| channel->ch_part[PART_OUT].ch_json_head.jq_next != NULL;

has_err_msg = channel->ch_part[PART_ERR].ch_fd != INVALID_FD

|| channel->ch_part[PART_ERR].ch_head.rq_next != NULL

|| channel->ch_part[PART_ERR].ch_json_head.jq_next != NULL;

return (channel->ch_callback.cb_name != NULL && (has_sock_msg

|| has_out_msg || has_err_msg))

|| ((channel->ch_part[PART_OUT].ch_callback.cb_name != NULL

|| channel->ch_part[PART_OUT].ch_bufref.br_buf != NULL)

&& has_out_msg)

|| ((channel->ch_part[PART_ERR].ch_callback.cb_name != NULL

|| channel->ch_part[PART_ERR].ch_bufref.br_buf != NULL)

&& has_err_msg);

}

/*

* Return TRUE if "channel" is closeable (i.e. all readable fds are closed).

*/

int

channel_can_close(channel_T *channel)

{

return channel->ch_to_be_closed == 0;

}

/*

* Close a channel and free all its resources.

* The "channel" pointer remains valid.

*/

static void

channel_free_contents(channel_T *channel)

{

channel_close(channel, TRUE);

channel_clear(channel);

ch_log(channel, "Freeing channel");

}

/*

* Unlink "channel" from the list of channels and free it.

*/

static void

channel_free_channel(channel_T *channel)

{

if (channel->ch_next != NULL)

channel->ch_next->ch_prev = channel->ch_prev;

if (channel->ch_prev == NULL)

first_channel = channel->ch_next;

else

channel->ch_prev->ch_next = channel->ch_next;

vim_free(channel);

}

static void

channel_free(channel_T *channel)

{

if (in_free_unref_items)

return;

if (safe_to_invoke_callback == 0)

channel->ch_to_be_freed = TRUE;

else

{

channel_free_contents(channel);

channel_free_channel(channel);

}

}

/*

* Close a channel and free all its resources if there is no further action

* possible, there is no callback to be invoked or the associated job was

* killed.

* Return TRUE if the channel was freed.

*/

static int

channel_may_free(channel_T *channel)

{

if (!channel_still_useful(channel))

{

channel_free(channel);

return TRUE;

}

return FALSE;

}

/*

* Decrement the reference count on "channel" and maybe free it when it goes

* down to zero. Don't free it if there is a pending action.

* Returns TRUE when the channel is no longer referenced.

*/

int

channel_unref(channel_T *channel)

{

if (channel != NULL && --channel->ch_refcount <= 0)

return channel_may_free(channel);

return FALSE;

}

int

free_unused_channels_contents(int copyID, int mask)

{

int did_free = FALSE;

channel_T *ch;

// This is invoked from the garbage collector, which only runs at a safe

// point.

++safe_to_invoke_callback;

FOR_ALL_CHANNELS(ch)

if (!channel_still_useful(ch)

&& (ch->ch_copyID & mask) != (copyID & mask))

{

// Free the channel and ordinary items it contains, but don't

// recurse into Lists, Dictionaries etc.

channel_free_contents(ch);

did_free = TRUE;

}

--safe_to_invoke_callback;

return did_free;

}

void

free_unused_channels(int copyID, int mask)

{

channel_T *ch;

channel_T *ch_next;

for (ch = first_channel; ch != NULL; ch = ch_next)

{

ch_next = ch->ch_next;

if (!channel_still_useful(ch)

&& (ch->ch_copyID & mask) != (copyID & mask))

// Free the channel struct itself.

channel_free_channel(ch);

}

}

#if defined(FEAT_GUI)

# if defined(FEAT_GUI_X11) || defined(FEAT_GUI_GTK)

/*

* Lookup the channel from the socket. Set "partp" to the fd index.

* Returns NULL when the socket isn't found.

*/

static channel_T *

channel_fd2channel(sock_T fd, ch_part_T *partp)

{

channel_T *channel;

ch_part_T part;

if (fd == INVALID_FD)

return NULL;

FOR_ALL_CHANNELS(channel)

{

for (part = PART_SOCK; part < PART_IN; ++part)

if (channel->ch_part[part].ch_fd == fd)

{

*partp = part;

return channel;

}

}

return NULL;

}

static void

channel_read_fd(int fd)

{

channel_T *channel;

ch_part_T part;

channel = channel_fd2channel(fd, &part);

if (channel == NULL)

ch_error(NULL, "Channel for fd %d not found", fd);

else

channel_read(channel, part, "channel_read_fd");

}

# endif

/*

* Read a command from netbeans.

*/

# ifdef FEAT_GUI_X11

static void

messageFromServerX11(XtPointer clientData,

int *unused1 UNUSED,

XtInputId *unused2 UNUSED)

{

channel_read_fd((int)(long)clientData);

}

# endif

# ifdef FEAT_GUI_GTK

# if GTK_CHECK_VERSION(3,0,0)

static gboolean

messageFromServerGtk3(GIOChannel *unused1 UNUSED,

GIOCondition unused2 UNUSED,

gpointer clientData)

{

channel_read_fd(GPOINTER_TO_INT(clientData));

return TRUE; // Return FALSE instead in case the event source is to

// be removed after this function returns.

}

# else

static void

messageFromServerGtk2(gpointer clientData,

gint unused1 UNUSED,

GdkInputCondition unused2 UNUSED)

{

channel_read_fd((int)(long)clientData);

}

# endif

# endif

static void

channel_gui_register_one(channel_T *channel, ch_part_T part UNUSED)

{

if (!CH_HAS_GUI)

return;

// gets stuck in handling events for a not connected channel

if (channel->ch_keep_open)

return;

# ifdef FEAT_GUI_X11

// Tell notifier we are interested in being called when there is input on

// the editor connection socket.

if (channel->ch_part[part].ch_inputHandler == (XtInputId)NULL)

{

ch_log(channel, "Registering part %s with fd %d",

ch_part_names[part], channel->ch_part[part].ch_fd);

channel->ch_part[part].ch_inputHandler = XtAppAddInput(

(XtAppContext)app_context,

channel->ch_part[part].ch_fd,

(XtPointer)(XtInputReadMask + XtInputExceptMask),

messageFromServerX11,

(XtPointer)(long)channel->ch_part[part].ch_fd);

}

# else

# ifdef FEAT_GUI_GTK

// Tell gdk we are interested in being called when there is input on the

// editor connection socket.

if (channel->ch_part[part].ch_inputHandler == 0)

{

ch_log(channel, "Registering part %s with fd %d",

ch_part_names[part], channel->ch_part[part].ch_fd);

# if GTK_CHECK_VERSION(3,0,0)

GIOChannel *chnnl = g_io_channel_unix_new(

(gint)channel->ch_part[part].ch_fd);

channel->ch_part[part].ch_inputHandler = g_io_add_watch(

chnnl,

G_IO_IN|G_IO_HUP|G_IO_ERR|G_IO_PRI,

messageFromServerGtk3,

GINT_TO_POINTER(channel->ch_part[part].ch_fd));

g_io_channel_unref(chnnl);

# else

channel->ch_part[part].ch_inputHandler = gdk_input_add(

(gint)channel->ch_part[part].ch_fd,

(GdkInputCondition)

((int)GDK_INPUT_READ + (int)GDK_INPUT_EXCEPTION),

messageFromServerGtk2,

(gpointer)(long)channel->ch_part[part].ch_fd);

# endif

}

# else

# ifdef FEAT_GUI_MACVIM

/* Tell Core Foundation we are interested in being called when there

* is input on the editor connection socket. */

if (channel->ch_part[part].ch_inputHandler == 0)

channel->ch_part[part].ch_inputHandler = gui_macvim_add_channel(

channel, part);

# endif

# endif

# endif

}

static void

channel_gui_register(channel_T *channel)

{

if (channel->CH_SOCK_FD != INVALID_FD)

channel_gui_register_one(channel, PART_SOCK);

if (channel->CH_OUT_FD != INVALID_FD

&& channel->CH_OUT_FD != channel->CH_SOCK_FD)

channel_gui_register_one(channel, PART_OUT);

if (channel->CH_ERR_FD != INVALID_FD

&& channel->CH_ERR_FD != channel->CH_SOCK_FD

&& channel->CH_ERR_FD != channel->CH_OUT_FD)

channel_gui_register_one(channel, PART_ERR);

}

/*

* Register any of our file descriptors with the GUI event handling system.

* Called when the GUI has started.

*/

void

channel_gui_register_all(void)

{

channel_T *channel;

FOR_ALL_CHANNELS(channel)

channel_gui_register(channel);

}

static void

channel_gui_unregister_one(channel_T *channel UNUSED, ch_part_T part UNUSED)

{

# ifdef FEAT_GUI_X11

if (channel->ch_part[part].ch_inputHandler != (XtInputId)NULL)

{

ch_log(channel, "Unregistering part %s", ch_part_names[part]);

XtRemoveInput(channel->ch_part[part].ch_inputHandler);

channel->ch_part[part].ch_inputHandler = (XtInputId)NULL;

}

# else

# ifdef FEAT_GUI_GTK

if (channel->ch_part[part].ch_inputHandler != 0)

{

ch_log(channel, "Unregistering part %s", ch_part_names[part]);

# if GTK_CHECK_VERSION(3,0,0)

g_source_remove(channel->ch_part[part].ch_inputHandler);

# else

gdk_input_remove(channel->ch_part[part].ch_inputHandler);

# endif

channel->ch_part[part].ch_inputHandler = 0;

}

# else

# ifdef FEAT_GUI_MACVIM

if (channel->ch_part[part].ch_inputHandler != 0)

{

gui_macvim_remove_channel(channel->ch_part[part].ch_inputHandler);

channel->ch_part[part].ch_inputHandler = 0;

}

# endif

# endif

# endif

}

static void

channel_gui_unregister(channel_T *channel)

{

ch_part_T part;

for (part = PART_SOCK; part < PART_IN; ++part)

channel_gui_unregister_one(channel, part);

}

#endif // FEAT_GUI

/*

* For Unix we need to call connect() again after connect() failed.

* On Win32 one time is sufficient.

*/

static int

channel_connect(

channel_T *channel,

const struct sockaddr *server_addr,

int server_addrlen,

int *waittime)

{

int sd = -1;

#ifdef MSWIN

u_long val = 1;

#endif

while (TRUE)

{

long elapsed_msec = 0;

int waitnow;

int ret;

if (sd >= 0)

sock_close(sd);

sd = socket(server_addr->sa_family, SOCK_STREAM, 0);

if (sd == -1)

{

ch_error(channel, "in socket() in channel_connect().");

PERROR(_(e_socket_in_channel_connect));

return -1;

}

if (*waittime >= 0)

{

// Make connect() non-blocking.

if (

#ifdef MSWIN

ioctlsocket(sd, FIONBIO, &val) < 0

#else

fcntl(sd, F_SETFL, O_NONBLOCK) < 0

#endif

)

{

SOCK_ERRNO;

ch_error(channel,

"channel_connect: Connect failed with errno %d", errno);

sock_close(sd);

return -1;

}

}

// Try connecting to the server.

ch_log(channel, "Connecting...");

ret = connect(sd, server_addr, server_addrlen);

if (ret == 0)

// The connection could be established.

break;

SOCK_ERRNO;

if (*waittime < 0 || (errno != EWOULDBLOCK

&& errno != ECONNREFUSED

#ifdef EINPROGRESS

&& errno != EINPROGRESS

#endif

))

{

ch_error(channel,

"channel_connect: Connect failed with errno %d", errno);

PERROR(_(e_cannot_connect_to_port));

sock_close(sd);

return -1;

}

else if (errno == ECONNREFUSED)

{

ch_error(channel, "channel_connect: Connection refused");

sock_close(sd);

return -1;

}

// Limit the waittime to 50 msec. If it doesn't work within this

// time we close the socket and try creating it again.

waitnow = *waittime > 50 ? 50 : *waittime;

// If connect() didn't finish then try using select() to wait for the

// connection to be made. For Win32 always use select() to wait.

{

struct timeval tv;

fd_set rfds;

fd_set wfds;

#ifndef MSWIN

int so_error = 0;

socklen_t so_error_len = sizeof(so_error);

struct timeval start_tv;

struct timeval end_tv;

#endif

FD_ZERO(&rfds);

FD_SET(sd, &rfds);

FD_ZERO(&wfds);

FD_SET(sd, &wfds);

tv.tv_sec = waitnow / 1000;

tv.tv_usec = (waitnow % 1000) * 1000;

#ifndef MSWIN

gettimeofday(&start_tv, NULL);

#endif

ch_log(channel,

"Waiting for connection (waiting %d msec)...", waitnow);

ret = select(sd + 1, &rfds, &wfds, NULL, &tv);

if (ret < 0)

{

SOCK_ERRNO;

ch_error(channel,

"channel_connect: Connect failed with errno %d", errno);

PERROR(_(e_cannot_connect_to_port));

sock_close(sd);

return -1;

}

#ifdef MSWIN

// On Win32: select() is expected to work and wait for up to

// "waitnow" msec for the socket to be open.

if (FD_ISSET(sd, &wfds))

break;

elapsed_msec = waitnow;

if (*waittime > 1 && elapsed_msec < *waittime)

{

*waittime -= elapsed_msec;

continue;

}

#else

// On Linux-like systems: See socket(7) for the behavior

// After putting the socket in non-blocking mode, connect() will

// return EINPROGRESS, select() will not wait (as if writing is

// possible), need to use getsockopt() to check if the socket is

// actually able to connect.

// We detect a failure to connect when either read and write fds

// are set. Use getsockopt() to find out what kind of failure.

if (FD_ISSET(sd, &rfds) || FD_ISSET(sd, &wfds))

{

ret = getsockopt(sd,

SOL_SOCKET, SO_ERROR, &so_error, &so_error_len);

if (ret < 0 || (so_error != 0

&& so_error != EWOULDBLOCK

&& so_error != ECONNREFUSED

# ifdef EINPROGRESS

&& so_error != EINPROGRESS

# endif

))

{

ch_error(channel,

"channel_connect: Connect failed with errno %d",

so_error);

PERROR(_(e_cannot_connect_to_port));

sock_close(sd);

return -1;

}

else if (errno == ECONNREFUSED)

{

ch_error(channel, "channel_connect: Connection refused");

sock_close(sd);

return -1;

}

}

if (FD_ISSET(sd, &wfds) && so_error == 0)

// Did not detect an error, connection is established.

break;

gettimeofday(&end_tv, NULL);

elapsed_msec = (end_tv.tv_sec - start_tv.tv_sec) * 1000

+ (end_tv.tv_usec - start_tv.tv_usec) / 1000;

#endif

}

#ifndef MSWIN

if (*waittime > 1 && elapsed_msec < *waittime)

{

// The port isn't ready but we also didn't get an error.

// This happens when the server didn't open the socket

// yet. Select() may return early, wait until the remaining

// "waitnow" and try again.

waitnow -= elapsed_msec;

*waittime -= elapsed_msec;

if (waitnow > 0)

{

mch_delay((long)waitnow, MCH_DELAY_IGNOREINPUT);

ui_breakcheck();

*waittime -= waitnow;

}

if (!got_int)

{

if (*waittime <= 0)

// give it one more try

*waittime = 1;

continue;

}

// we were interrupted, behave as if timed out

}

#endif

// We timed out.

ch_error(channel, "Connection timed out");

sock_close(sd);

return -1;

}

if (*waittime >= 0)

{

#ifdef MSWIN

val = 0;

ioctlsocket(sd, FIONBIO, &val);

#else

(void)fcntl(sd, F_SETFL, 0);

#endif

}

return sd;

}

/*

* Open a socket channel to the UNIX socket at "path".

* Returns the channel for success.

* Returns NULL for failure.

*/

channel_T *

channel_open_unix(

const char *path,

void (*nb_close_cb)(void))

{

channel_T *channel = NULL;

int sd = -1;

size_t path_len = STRLEN(path);

struct sockaddr_un server;

size_t server_len;

int waittime = -1;

if (*path == NUL || path_len >= sizeof(server.sun_path))

{

semsg(_(e_invalid_argument_str), path);

return NULL;

}

#ifdef MSWIN

channel_init_winsock();

#endif

channel = add_channel();

if (channel == NULL)

{

ch_error(NULL, "Cannot allocate channel.");

return NULL;

}

CLEAR_FIELD(server);

server.sun_family = AF_UNIX;

STRNCPY(server.sun_path, path, sizeof(server.sun_path) - 1);

ch_log(channel, "Trying to connect to %s", path);

server_len = offsetof(struct sockaddr_un, sun_path) + path_len + 1;

sd = channel_connect(channel, (struct sockaddr *)&server, (int)server_len,

&waittime);

if (sd < 0)

{

channel_free(channel);

return NULL;

}

ch_log(channel, "Connection made");

channel->CH_SOCK_FD = (sock_T)sd;

channel->ch_nb_close_cb = nb_close_cb;

channel->ch_hostname = (char *)vim_strsave((char_u *)path);

channel->ch_port = 0;

channel->ch_to_be_closed |= (1U << PART_SOCK);

#ifdef FEAT_GUI

channel_gui_register_one(channel, PART_SOCK);

#endif

return channel;

}

/*

* Open a socket channel to "hostname":"port".

* "waittime" is the time in msec to wait for the connection.

* When negative wait forever.

* Returns the channel for success.

* Returns NULL for failure.

*/

channel_T *

channel_open(

const char *hostname,

int port,

int waittime,

void (*nb_close_cb)(void))

{

int sd = -1;

channel_T *channel = NULL;

#ifdef FEAT_IPV6

int err;

struct addrinfo hints;

struct addrinfo *res = NULL;

struct addrinfo *addr = NULL;

#else

struct sockaddr_in server;

struct hostent *host = NULL;

#endif

#ifdef MSWIN

channel_init_winsock();

#endif

channel = add_channel();

if (channel == NULL)

{

ch_error(NULL, "Cannot allocate channel.");

return NULL;

}

// Get the server internet address and put into addr structure fill in the

// socket address structure and connect to server.

#ifdef FEAT_IPV6

CLEAR_FIELD(hints);

hints.ai_family = AF_UNSPEC;

hints.ai_socktype = SOCK_STREAM;

# if defined(__ANDROID__)

hints.ai_flags = AI_ADDRCONFIG;

# elif defined(AI_ADDRCONFIG) && defined(AI_V4MAPPED)

hints.ai_flags = AI_ADDRCONFIG | AI_V4MAPPED;

# endif

// Set port number manually in order to prevent name resolution services

// from being invoked in the environment where AI_NUMERICSERV is not

// defined.

if ((err = getaddrinfo(hostname, NULL, &hints, &res)) != 0)

{

ch_error(channel, "in getaddrinfo() in channel_open()");

semsg(_(e_getaddrinfo_in_channel_open_str), gai_strerror(err));

channel_free(channel);

return NULL;

}

// Count the number of addresses for timeout distribution

int addr_count = 0;

for (addr = res; addr != NULL; addr = addr->ai_next)

addr_count++;

// On Mac and Solaris a zero timeout almost never works. Waiting for

// one millisecond already helps a lot. Later Mac systems (using IPv6)

// need more time, 15 milliseconds appears to work well.

// Let's do it for all systems, because we don't know why this is

// needed.

if (waittime == 0)

waittime = 15;

int addr_index = 0;

for (addr = res; addr != NULL; addr = addr->ai_next, addr_index++)

{

const char *dst = hostname;

# ifdef HAVE_INET_NTOP

const void *src = NULL;

char buf[NUMBUFLEN];

# endif

int try_waittime;

int before_waittime;

int consumed;

int remaining_addrs;

if (addr->ai_family == AF_INET6)

{

struct sockaddr_in6 *sai = (struct sockaddr_in6 *)addr->ai_addr;

sai->sin6_port = htons(port);

# ifdef HAVE_INET_NTOP

src = &sai->sin6_addr;

# endif

}

else if (addr->ai_family == AF_INET)

{

struct sockaddr_in *sai = (struct sockaddr_in *)addr->ai_addr;