mirror of
https://github.com/vim/vim.git
synced 2025-07-04 23:07:33 -04:00
Problem: Cppcheck warnings. Solution: Use temp variable. Change NUL to NULL. Swap conditions. (Dominique Pelle)
5165 lines
121 KiB
C
5165 lines
121 KiB
C
/* 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) || defined(PROTO)
|
|
|
|
/* 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 WIN32
|
|
/* 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)
|
|
#else
|
|
# include <netdb.h>
|
|
# include <netinet/in.h>
|
|
|
|
# include <sys/socket.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);
|
|
|
|
/* Whether a redraw is needed for appending a line to a buffer. */
|
|
static int channel_need_redraw = FALSE;
|
|
|
|
/* Whether we are inside channel_parse_messages() or another situation where it
|
|
* is safe to invoke callbacks. */
|
|
static int safe_to_invoke_callback = 0;
|
|
|
|
static char *part_names[] = {"sock", "out", "err", "in"};
|
|
|
|
#ifdef WIN32
|
|
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)
|
|
{
|
|
HANDLE h = (HANDLE)fd;
|
|
DWORD nwrite;
|
|
|
|
if (!WriteFile(h, buf, (DWORD)len, &nwrite, NULL))
|
|
return -1;
|
|
return (int)nwrite;
|
|
}
|
|
|
|
static void
|
|
fd_close(sock_T fd)
|
|
{
|
|
HANDLE h = (HANDLE)fd;
|
|
|
|
CloseHandle(h);
|
|
}
|
|
#endif
|
|
|
|
/* Log file opened with ch_logfile(). */
|
|
static FILE *log_fd = NULL;
|
|
#ifdef FEAT_RELTIME
|
|
static proftime_T log_start;
|
|
#endif
|
|
|
|
void
|
|
ch_logfile(char_u *fname, char_u *opt)
|
|
{
|
|
FILE *file = NULL;
|
|
|
|
if (log_fd != NULL)
|
|
fclose(log_fd);
|
|
|
|
if (*fname != NUL)
|
|
{
|
|
file = fopen((char *)fname, *opt == 'w' ? "w" : "a");
|
|
if (file == NULL)
|
|
{
|
|
EMSG2(_(e_notopen), fname);
|
|
return;
|
|
}
|
|
}
|
|
log_fd = file;
|
|
|
|
if (log_fd != NULL)
|
|
{
|
|
fprintf(log_fd, "==== start log session ====\n");
|
|
#ifdef FEAT_RELTIME
|
|
profile_start(&log_start);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
int
|
|
ch_log_active(void)
|
|
{
|
|
return log_fd != NULL;
|
|
}
|
|
|
|
static void
|
|
ch_log_lead(char *what, channel_T *ch)
|
|
{
|
|
if (log_fd != NULL)
|
|
{
|
|
#ifdef FEAT_RELTIME
|
|
proftime_T log_now;
|
|
|
|
profile_start(&log_now);
|
|
profile_sub(&log_now, &log_start);
|
|
fprintf(log_fd, "%s ", profile_msg(&log_now));
|
|
#endif
|
|
if (ch != NULL)
|
|
fprintf(log_fd, "%son %d: ", what, ch->ch_id);
|
|
else
|
|
fprintf(log_fd, "%s: ", what);
|
|
}
|
|
}
|
|
|
|
static int did_log_msg = TRUE;
|
|
|
|
void
|
|
ch_log(channel_T *ch, char *msg)
|
|
{
|
|
if (log_fd != NULL)
|
|
{
|
|
ch_log_lead("", ch);
|
|
fputs(msg, log_fd);
|
|
fputc('\n', log_fd);
|
|
fflush(log_fd);
|
|
did_log_msg = TRUE;
|
|
}
|
|
}
|
|
|
|
static void
|
|
ch_logn(channel_T *ch, char *msg, int nr)
|
|
{
|
|
if (log_fd != NULL)
|
|
{
|
|
ch_log_lead("", ch);
|
|
fprintf(log_fd, msg, nr);
|
|
fputc('\n', log_fd);
|
|
fflush(log_fd);
|
|
did_log_msg = TRUE;
|
|
}
|
|
}
|
|
|
|
void
|
|
ch_logs(channel_T *ch, char *msg, char *name)
|
|
{
|
|
if (log_fd != NULL)
|
|
{
|
|
ch_log_lead("", ch);
|
|
fprintf(log_fd, msg, name);
|
|
fputc('\n', log_fd);
|
|
fflush(log_fd);
|
|
did_log_msg = TRUE;
|
|
}
|
|
}
|
|
|
|
static void
|
|
ch_logsn(channel_T *ch, char *msg, char *name, int nr)
|
|
{
|
|
if (log_fd != NULL)
|
|
{
|
|
ch_log_lead("", ch);
|
|
fprintf(log_fd, msg, name, nr);
|
|
fputc('\n', log_fd);
|
|
fflush(log_fd);
|
|
did_log_msg = TRUE;
|
|
}
|
|
}
|
|
|
|
static void
|
|
ch_error(channel_T *ch, char *msg)
|
|
{
|
|
if (log_fd != NULL)
|
|
{
|
|
ch_log_lead("ERR ", ch);
|
|
fputs(msg, log_fd);
|
|
fputc('\n', log_fd);
|
|
fflush(log_fd);
|
|
did_log_msg = TRUE;
|
|
}
|
|
}
|
|
|
|
static void
|
|
ch_errorn(channel_T *ch, char *msg, int nr)
|
|
{
|
|
if (log_fd != NULL)
|
|
{
|
|
ch_log_lead("ERR ", ch);
|
|
fprintf(log_fd, msg, nr);
|
|
fputc('\n', log_fd);
|
|
fflush(log_fd);
|
|
did_log_msg = TRUE;
|
|
}
|
|
}
|
|
|
|
static void
|
|
ch_errors(channel_T *ch, char *msg, char *arg)
|
|
{
|
|
if (log_fd != NULL)
|
|
{
|
|
ch_log_lead("ERR ", ch);
|
|
fprintf(log_fd, msg, arg);
|
|
fputc('\n', log_fd);
|
|
fflush(log_fd);
|
|
did_log_msg = TRUE;
|
|
}
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
# undef PERROR
|
|
# define PERROR(msg) (void)emsg3((char_u *)"%s: %s", \
|
|
(char_u *)msg, (char_u *)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 = (channel_T *)alloc_clear((int)sizeof(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
|
|
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.
|
|
*/
|
|
static 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 != 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 != NULL && (has_sock_msg
|
|
|| has_out_msg || has_err_msg))
|
|
|| ((channel->ch_part[PART_OUT].ch_callback != NULL
|
|
|| channel->ch_part[PART_OUT].ch_bufref.br_buf != NULL)
|
|
&& has_out_msg)
|
|
|| ((channel->ch_part[PART_ERR].ch_callback != NULL
|
|
|| channel->ch_part[PART_ERR].ch_bufref.br_buf != NULL)
|
|
&& has_err_msg);
|
|
}
|
|
|
|
/*
|
|
* Close a channel and free all its resources.
|
|
*/
|
|
static void
|
|
channel_free_contents(channel_T *channel)
|
|
{
|
|
channel_close(channel, TRUE);
|
|
channel_clear(channel);
|
|
ch_log(channel, "Freeing channel");
|
|
}
|
|
|
|
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)
|
|
{
|
|
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 (ch = first_channel; ch != NULL; ch = ch->ch_next)
|
|
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) || defined(PROTO)
|
|
|
|
#if defined(FEAT_GUI_X11) || defined(FEAT_GUI_GTK)
|
|
static void
|
|
channel_read_fd(int fd)
|
|
{
|
|
channel_T *channel;
|
|
ch_part_T part;
|
|
|
|
channel = channel_fd2channel(fd, &part);
|
|
if (channel == NULL)
|
|
ch_errorn(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
|
|
messageFromServer(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
|
|
messageFromServer(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
|
|
messageFromServer(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)
|
|
{
|
|
if (!CH_HAS_GUI)
|
|
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)
|
|
channel->ch_part[part].ch_inputHandler = XtAppAddInput(
|
|
(XtAppContext)app_context,
|
|
channel->ch_part[part].ch_fd,
|
|
(XtPointer)(XtInputReadMask + XtInputExceptMask),
|
|
messageFromServer,
|
|
(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)
|
|
# 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,
|
|
messageFromServer,
|
|
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),
|
|
messageFromServer,
|
|
(gpointer)(long)channel->ch_part[part].ch_fd);
|
|
# 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_gui_register_one(channel, PART_OUT);
|
|
if (channel->CH_ERR_FD != INVALID_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 (channel = first_channel; channel != NULL; channel = channel->ch_next)
|
|
channel_gui_register(channel);
|
|
}
|
|
|
|
static void
|
|
channel_gui_unregister_one(channel_T *channel, ch_part_T part)
|
|
{
|
|
# ifdef FEAT_GUI_X11
|
|
if (channel->ch_part[part].ch_inputHandler != (XtInputId)NULL)
|
|
{
|
|
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)
|
|
{
|
|
# 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;
|
|
}
|
|
# 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
|
|
|
|
static char *e_cannot_connect = N_("E902: Cannot connect to port");
|
|
|
|
/*
|
|
* 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(
|
|
char *hostname,
|
|
int port_in,
|
|
int waittime,
|
|
void (*nb_close_cb)(void))
|
|
{
|
|
int sd = -1;
|
|
struct sockaddr_in server;
|
|
struct hostent *host;
|
|
#ifdef WIN32
|
|
u_short port = port_in;
|
|
u_long val = 1;
|
|
#else
|
|
int port = port_in;
|
|
#endif
|
|
channel_T *channel;
|
|
int ret;
|
|
|
|
#ifdef WIN32
|
|
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 */
|
|
vim_memset((char *)&server, 0, sizeof(server));
|
|
server.sin_family = AF_INET;
|
|
server.sin_port = htons(port);
|
|
if ((host = gethostbyname(hostname)) == NULL)
|
|
{
|
|
ch_error(channel, "in gethostbyname() in channel_open()");
|
|
PERROR(_("E901: gethostbyname() in channel_open()"));
|
|
channel_free(channel);
|
|
return NULL;
|
|
}
|
|
{
|
|
char *p;
|
|
|
|
/* When using host->h_addr directly ubsan warns for it to not be
|
|
* aligned. First copy the pointer to aviod that. */
|
|
memcpy(&p, &host->h_addr, sizeof(p));
|
|
memcpy((char *)&server.sin_addr, p, host->h_length);
|
|
}
|
|
|
|
/* On Mac and Solaris a zero timeout almost never works. At least wait
|
|
* one millisecond. Let's do it for all systems, because we don't know why
|
|
* this is needed. */
|
|
if (waittime == 0)
|
|
waittime = 1;
|
|
|
|
/*
|
|
* For Unix we need to call connect() again after connect() failed.
|
|
* On Win32 one time is sufficient.
|
|
*/
|
|
while (TRUE)
|
|
{
|
|
long elapsed_msec = 0;
|
|
int waitnow;
|
|
|
|
if (sd >= 0)
|
|
sock_close(sd);
|
|
sd = socket(AF_INET, SOCK_STREAM, 0);
|
|
if (sd == -1)
|
|
{
|
|
ch_error(channel, "in socket() in channel_open().");
|
|
PERROR(_("E898: socket() in channel_open()"));
|
|
channel_free(channel);
|
|
return NULL;
|
|
}
|
|
|
|
if (waittime >= 0)
|
|
{
|
|
/* Make connect() non-blocking. */
|
|
if (
|
|
#ifdef _WIN32
|
|
ioctlsocket(sd, FIONBIO, &val) < 0
|
|
#else
|
|
fcntl(sd, F_SETFL, O_NONBLOCK) < 0
|
|
#endif
|
|
)
|
|
{
|
|
SOCK_ERRNO;
|
|
ch_errorn(channel,
|
|
"channel_open: Connect failed with errno %d", errno);
|
|
sock_close(sd);
|
|
channel_free(channel);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* Try connecting to the server. */
|
|
ch_logsn(channel, "Connecting to %s port %d", hostname, port);
|
|
ret = connect(sd, (struct sockaddr *)&server, sizeof(server));
|
|
|
|
if (ret == 0)
|
|
/* The connection could be established. */
|
|
break;
|
|
|
|
SOCK_ERRNO;
|
|
if (waittime < 0 || (errno != EWOULDBLOCK
|
|
&& errno != ECONNREFUSED
|
|
#ifdef EINPROGRESS
|
|
&& errno != EINPROGRESS
|
|
#endif
|
|
))
|
|
{
|
|
ch_errorn(channel,
|
|
"channel_open: Connect failed with errno %d", errno);
|
|
PERROR(_(e_cannot_connect));
|
|
sock_close(sd);
|
|
channel_free(channel);
|
|
return NULL;
|
|
}
|
|
|
|
/* 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. */
|
|
#ifndef WIN32
|
|
if (errno != ECONNREFUSED)
|
|
#endif
|
|
{
|
|
struct timeval tv;
|
|
fd_set rfds;
|
|
fd_set wfds;
|
|
#ifndef WIN32
|
|
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 WIN32
|
|
gettimeofday(&start_tv, NULL);
|
|
#endif
|
|
ch_logn(channel,
|
|
"Waiting for connection (waiting %d msec)...", waitnow);
|
|
ret = select((int)sd + 1, &rfds, &wfds, NULL, &tv);
|
|
|
|
if (ret < 0)
|
|
{
|
|
SOCK_ERRNO;
|
|
ch_errorn(channel,
|
|
"channel_open: Connect failed with errno %d", errno);
|
|
PERROR(_(e_cannot_connect));
|
|
sock_close(sd);
|
|
channel_free(channel);
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef WIN32
|
|
/* 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_errorn(channel,
|
|
"channel_open: Connect failed with errno %d",
|
|
so_error);
|
|
PERROR(_(e_cannot_connect));
|
|
sock_close(sd);
|
|
channel_free(channel);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
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 WIN32
|
|
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, TRUE);
|
|
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);
|
|
channel_free(channel);
|
|
return NULL;
|
|
}
|
|
|
|
ch_log(channel, "Connection made");
|
|
|
|
if (waittime >= 0)
|
|
{
|
|
#ifdef _WIN32
|
|
val = 0;
|
|
ioctlsocket(sd, FIONBIO, &val);
|
|
#else
|
|
(void)fcntl(sd, F_SETFL, 0);
|
|
#endif
|
|
}
|
|
|
|
channel->CH_SOCK_FD = (sock_T)sd;
|
|
channel->ch_nb_close_cb = nb_close_cb;
|
|
channel->ch_hostname = (char *)vim_strsave((char_u *)hostname);
|
|
channel->ch_port = port_in;
|
|
channel->ch_to_be_closed |= (1 << PART_SOCK);
|
|
|
|
#ifdef FEAT_GUI
|
|
channel_gui_register_one(channel, PART_SOCK);
|
|
#endif
|
|
|
|
return channel;
|
|
}
|
|
|
|
/*
|
|
* Implements ch_open().
|
|
*/
|
|
channel_T *
|
|
channel_open_func(typval_T *argvars)
|
|
{
|
|
char_u *address;
|
|
char_u *p;
|
|
char *rest;
|
|
int port;
|
|
jobopt_T opt;
|
|
channel_T *channel = NULL;
|
|
|
|
address = get_tv_string(&argvars[0]);
|
|
if (argvars[1].v_type != VAR_UNKNOWN
|
|
&& (argvars[1].v_type != VAR_DICT || argvars[1].vval.v_dict == NULL))
|
|
{
|
|
EMSG(_(e_invarg));
|
|
return NULL;
|
|
}
|
|
|
|
/* parse address */
|
|
p = vim_strchr(address, ':');
|
|
if (p == NULL)
|
|
{
|
|
EMSG2(_(e_invarg2), address);
|
|
return NULL;
|
|
}
|
|
*p++ = NUL;
|
|
port = strtol((char *)p, &rest, 10);
|
|
if (*address == NUL || port <= 0 || *rest != NUL)
|
|
{
|
|
p[-1] = ':';
|
|
EMSG2(_(e_invarg2), address);
|
|
return NULL;
|
|
}
|
|
|
|
/* parse options */
|
|
clear_job_options(&opt);
|
|
opt.jo_mode = MODE_JSON;
|
|
opt.jo_timeout = 2000;
|
|
if (get_job_options(&argvars[1], &opt,
|
|
JO_MODE_ALL + JO_CB_ALL + JO_WAITTIME + JO_TIMEOUT_ALL) == FAIL)
|
|
goto theend;
|
|
if (opt.jo_timeout < 0)
|
|
{
|
|
EMSG(_(e_invarg));
|
|
goto theend;
|
|
}
|
|
|
|
channel = channel_open((char *)address, port, opt.jo_waittime, NULL);
|
|
if (channel != NULL)
|
|
{
|
|
opt.jo_set = JO_ALL;
|
|
channel_set_options(channel, &opt);
|
|
}
|
|
theend:
|
|
free_job_options(&opt);
|
|
return channel;
|
|
}
|
|
|
|
static void
|
|
ch_close_part(channel_T *channel, ch_part_T part)
|
|
{
|
|
sock_T *fd = &channel->ch_part[part].ch_fd;
|
|
|
|
if (*fd != INVALID_FD)
|
|
{
|
|
if (part == PART_SOCK)
|
|
sock_close(*fd);
|
|
else
|
|
fd_close(*fd);
|
|
*fd = INVALID_FD;
|
|
|
|
channel->ch_to_be_closed &= ~(1 << part);
|
|
}
|
|
}
|
|
|
|
void
|
|
channel_set_pipes(channel_T *channel, sock_T in, sock_T out, sock_T err)
|
|
{
|
|
if (in != INVALID_FD)
|
|
{
|
|
ch_close_part(channel, PART_IN);
|
|
channel->CH_IN_FD = in;
|
|
}
|
|
if (out != INVALID_FD)
|
|
{
|
|
# if defined(FEAT_GUI)
|
|
channel_gui_unregister_one(channel, PART_OUT);
|
|
# endif
|
|
ch_close_part(channel, PART_OUT);
|
|
channel->CH_OUT_FD = out;
|
|
channel->ch_to_be_closed |= (1 << PART_OUT);
|
|
# if defined(FEAT_GUI)
|
|
channel_gui_register_one(channel, PART_OUT);
|
|
# endif
|
|
}
|
|
if (err != INVALID_FD)
|
|
{
|
|
# if defined(FEAT_GUI)
|
|
channel_gui_unregister_one(channel, PART_ERR);
|
|
# endif
|
|
ch_close_part(channel, PART_ERR);
|
|
channel->CH_ERR_FD = err;
|
|
channel->ch_to_be_closed |= (1 << PART_ERR);
|
|
# if defined(FEAT_GUI)
|
|
channel_gui_register_one(channel, PART_ERR);
|
|
# endif
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Sets the job the channel is associated with and associated options.
|
|
* This does not keep a refcount, when the job is freed ch_job is cleared.
|
|
*/
|
|
void
|
|
channel_set_job(channel_T *channel, job_T *job, jobopt_T *options)
|
|
{
|
|
channel->ch_job = job;
|
|
|
|
channel_set_options(channel, options);
|
|
|
|
if (job->jv_in_buf != NULL)
|
|
{
|
|
chanpart_T *in_part = &channel->ch_part[PART_IN];
|
|
|
|
set_bufref(&in_part->ch_bufref, job->jv_in_buf);
|
|
ch_logs(channel, "reading from buffer '%s'",
|
|
(char *)in_part->ch_bufref.br_buf->b_ffname);
|
|
if (options->jo_set & JO_IN_TOP)
|
|
{
|
|
if (options->jo_in_top == 0 && !(options->jo_set & JO_IN_BOT))
|
|
{
|
|
/* Special mode: send last-but-one line when appending a line
|
|
* to the buffer. */
|
|
in_part->ch_bufref.br_buf->b_write_to_channel = TRUE;
|
|
in_part->ch_buf_append = TRUE;
|
|
in_part->ch_buf_top =
|
|
in_part->ch_bufref.br_buf->b_ml.ml_line_count + 1;
|
|
}
|
|
else
|
|
in_part->ch_buf_top = options->jo_in_top;
|
|
}
|
|
else
|
|
in_part->ch_buf_top = 1;
|
|
if (options->jo_set & JO_IN_BOT)
|
|
in_part->ch_buf_bot = options->jo_in_bot;
|
|
else
|
|
in_part->ch_buf_bot = in_part->ch_bufref.br_buf->b_ml.ml_line_count;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Find a buffer matching "name" or create a new one.
|
|
* Returns NULL if there is something very wrong (error already reported).
|
|
*/
|
|
static buf_T *
|
|
find_buffer(char_u *name, int err, int msg)
|
|
{
|
|
buf_T *buf = NULL;
|
|
buf_T *save_curbuf = curbuf;
|
|
|
|
if (name != NULL && *name != NUL)
|
|
{
|
|
buf = buflist_findname(name);
|
|
if (buf == NULL)
|
|
buf = buflist_findname_exp(name);
|
|
}
|
|
if (buf == NULL)
|
|
{
|
|
buf = buflist_new(name == NULL || *name == NUL ? NULL : name,
|
|
NULL, (linenr_T)0, BLN_LISTED | BLN_NEW);
|
|
if (buf == NULL)
|
|
return NULL;
|
|
buf_copy_options(buf, BCO_ENTER);
|
|
curbuf = buf;
|
|
#ifdef FEAT_QUICKFIX
|
|
set_option_value((char_u *)"bt", 0L, (char_u *)"nofile", OPT_LOCAL);
|
|
set_option_value((char_u *)"bh", 0L, (char_u *)"hide", OPT_LOCAL);
|
|
#endif
|
|
if (curbuf->b_ml.ml_mfp == NULL)
|
|
ml_open(curbuf);
|
|
if (msg)
|
|
ml_replace(1, (char_u *)(err ? "Reading from channel error..."
|
|
: "Reading from channel output..."), TRUE);
|
|
changed_bytes(1, 0);
|
|
curbuf = save_curbuf;
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
static void
|
|
set_callback(
|
|
char_u **cbp,
|
|
partial_T **pp,
|
|
char_u *callback,
|
|
partial_T *partial)
|
|
{
|
|
free_callback(*cbp, *pp);
|
|
if (callback != NULL && *callback != NUL)
|
|
{
|
|
if (partial != NULL)
|
|
*cbp = partial_name(partial);
|
|
else
|
|
{
|
|
*cbp = vim_strsave(callback);
|
|
func_ref(*cbp);
|
|
}
|
|
}
|
|
else
|
|
*cbp = NULL;
|
|
*pp = partial;
|
|
if (partial != NULL)
|
|
++partial->pt_refcount;
|
|
}
|
|
|
|
/*
|
|
* Set various properties from an "opt" argument.
|
|
*/
|
|
void
|
|
channel_set_options(channel_T *channel, jobopt_T *opt)
|
|
{
|
|
ch_part_T part;
|
|
|
|
if (opt->jo_set & JO_MODE)
|
|
for (part = PART_SOCK; part < PART_COUNT; ++part)
|
|
channel->ch_part[part].ch_mode = opt->jo_mode;
|
|
if (opt->jo_set & JO_IN_MODE)
|
|
channel->ch_part[PART_IN].ch_mode = opt->jo_in_mode;
|
|
if (opt->jo_set & JO_OUT_MODE)
|
|
channel->ch_part[PART_OUT].ch_mode = opt->jo_out_mode;
|
|
if (opt->jo_set & JO_ERR_MODE)
|
|
channel->ch_part[PART_ERR].ch_mode = opt->jo_err_mode;
|
|
|
|
if (opt->jo_set & JO_TIMEOUT)
|
|
for (part = PART_SOCK; part < PART_COUNT; ++part)
|
|
channel->ch_part[part].ch_timeout = opt->jo_timeout;
|
|
if (opt->jo_set & JO_OUT_TIMEOUT)
|
|
channel->ch_part[PART_OUT].ch_timeout = opt->jo_out_timeout;
|
|
if (opt->jo_set & JO_ERR_TIMEOUT)
|
|
channel->ch_part[PART_ERR].ch_timeout = opt->jo_err_timeout;
|
|
if (opt->jo_set & JO_BLOCK_WRITE)
|
|
channel->ch_part[PART_IN].ch_block_write = 1;
|
|
|
|
if (opt->jo_set & JO_CALLBACK)
|
|
set_callback(&channel->ch_callback, &channel->ch_partial,
|
|
opt->jo_callback, opt->jo_partial);
|
|
if (opt->jo_set & JO_OUT_CALLBACK)
|
|
set_callback(&channel->ch_part[PART_OUT].ch_callback,
|
|
&channel->ch_part[PART_OUT].ch_partial,
|
|
opt->jo_out_cb, opt->jo_out_partial);
|
|
if (opt->jo_set & JO_ERR_CALLBACK)
|
|
set_callback(&channel->ch_part[PART_ERR].ch_callback,
|
|
&channel->ch_part[PART_ERR].ch_partial,
|
|
opt->jo_err_cb, opt->jo_err_partial);
|
|
if (opt->jo_set & JO_CLOSE_CALLBACK)
|
|
set_callback(&channel->ch_close_cb, &channel->ch_close_partial,
|
|
opt->jo_close_cb, opt->jo_close_partial);
|
|
channel->ch_drop_never = opt->jo_drop_never;
|
|
|
|
if ((opt->jo_set & JO_OUT_IO) && opt->jo_io[PART_OUT] == JIO_BUFFER)
|
|
{
|
|
buf_T *buf;
|
|
|
|
/* writing output to a buffer. Default mode is NL. */
|
|
if (!(opt->jo_set & JO_OUT_MODE))
|
|
channel->ch_part[PART_OUT].ch_mode = MODE_NL;
|
|
if (opt->jo_set & JO_OUT_BUF)
|
|
{
|
|
buf = buflist_findnr(opt->jo_io_buf[PART_OUT]);
|
|
if (buf == NULL)
|
|
EMSGN(_(e_nobufnr), (long)opt->jo_io_buf[PART_OUT]);
|
|
}
|
|
else
|
|
{
|
|
int msg = TRUE;
|
|
|
|
if (opt->jo_set2 & JO2_OUT_MSG)
|
|
msg = opt->jo_message[PART_OUT];
|
|
buf = find_buffer(opt->jo_io_name[PART_OUT], FALSE, msg);
|
|
}
|
|
if (buf != NULL)
|
|
{
|
|
if (opt->jo_set & JO_OUT_MODIFIABLE)
|
|
channel->ch_part[PART_OUT].ch_nomodifiable =
|
|
!opt->jo_modifiable[PART_OUT];
|
|
|
|
if (!buf->b_p_ma && !channel->ch_part[PART_OUT].ch_nomodifiable)
|
|
{
|
|
EMSG(_(e_modifiable));
|
|
}
|
|
else
|
|
{
|
|
ch_logs(channel, "writing out to buffer '%s'",
|
|
(char *)buf->b_ffname);
|
|
set_bufref(&channel->ch_part[PART_OUT].ch_bufref, buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((opt->jo_set & JO_ERR_IO) && (opt->jo_io[PART_ERR] == JIO_BUFFER
|
|
|| (opt->jo_io[PART_ERR] == JIO_OUT && (opt->jo_set & JO_OUT_IO)
|
|
&& opt->jo_io[PART_OUT] == JIO_BUFFER)))
|
|
{
|
|
buf_T *buf;
|
|
|
|
/* writing err to a buffer. Default mode is NL. */
|
|
if (!(opt->jo_set & JO_ERR_MODE))
|
|
channel->ch_part[PART_ERR].ch_mode = MODE_NL;
|
|
if (opt->jo_io[PART_ERR] == JIO_OUT)
|
|
buf = channel->ch_part[PART_OUT].ch_bufref.br_buf;
|
|
else if (opt->jo_set & JO_ERR_BUF)
|
|
{
|
|
buf = buflist_findnr(opt->jo_io_buf[PART_ERR]);
|
|
if (buf == NULL)
|
|
EMSGN(_(e_nobufnr), (long)opt->jo_io_buf[PART_ERR]);
|
|
}
|
|
else
|
|
{
|
|
int msg = TRUE;
|
|
|
|
if (opt->jo_set2 & JO2_ERR_MSG)
|
|
msg = opt->jo_message[PART_ERR];
|
|
buf = find_buffer(opt->jo_io_name[PART_ERR], TRUE, msg);
|
|
}
|
|
if (buf != NULL)
|
|
{
|
|
if (opt->jo_set & JO_ERR_MODIFIABLE)
|
|
channel->ch_part[PART_ERR].ch_nomodifiable =
|
|
!opt->jo_modifiable[PART_ERR];
|
|
if (!buf->b_p_ma && !channel->ch_part[PART_ERR].ch_nomodifiable)
|
|
{
|
|
EMSG(_(e_modifiable));
|
|
}
|
|
else
|
|
{
|
|
ch_logs(channel, "writing err to buffer '%s'",
|
|
(char *)buf->b_ffname);
|
|
set_bufref(&channel->ch_part[PART_ERR].ch_bufref, buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
channel->ch_part[PART_OUT].ch_io = opt->jo_io[PART_OUT];
|
|
channel->ch_part[PART_ERR].ch_io = opt->jo_io[PART_ERR];
|
|
channel->ch_part[PART_IN].ch_io = opt->jo_io[PART_IN];
|
|
}
|
|
|
|
/*
|
|
* Set the callback for "channel"/"part" for the response with "id".
|
|
*/
|
|
void
|
|
channel_set_req_callback(
|
|
channel_T *channel,
|
|
ch_part_T part,
|
|
char_u *callback,
|
|
partial_T *partial,
|
|
int id)
|
|
{
|
|
cbq_T *head = &channel->ch_part[part].ch_cb_head;
|
|
cbq_T *item = (cbq_T *)alloc((int)sizeof(cbq_T));
|
|
|
|
if (item != NULL)
|
|
{
|
|
item->cq_partial = partial;
|
|
if (partial != NULL)
|
|
{
|
|
++partial->pt_refcount;
|
|
item->cq_callback = callback;
|
|
}
|
|
else
|
|
{
|
|
item->cq_callback = vim_strsave(callback);
|
|
func_ref(item->cq_callback);
|
|
}
|
|
item->cq_seq_nr = id;
|
|
item->cq_prev = head->cq_prev;
|
|
head->cq_prev = item;
|
|
item->cq_next = NULL;
|
|
if (item->cq_prev == NULL)
|
|
head->cq_next = item;
|
|
else
|
|
item->cq_prev->cq_next = item;
|
|
}
|
|
}
|
|
|
|
static void
|
|
write_buf_line(buf_T *buf, linenr_T lnum, channel_T *channel)
|
|
{
|
|
char_u *line = ml_get_buf(buf, lnum, FALSE);
|
|
int len = (int)STRLEN(line);
|
|
char_u *p;
|
|
int i;
|
|
|
|
/* Need to make a copy to be able to append a NL. */
|
|
if ((p = alloc(len + 2)) == NULL)
|
|
return;
|
|
memcpy((char *)p, (char *)line, len);
|
|
|
|
for (i = 0; i < len; ++i)
|
|
if (p[i] == NL)
|
|
p[i] = NUL;
|
|
|
|
p[len] = NL;
|
|
p[len + 1] = NUL;
|
|
channel_send(channel, PART_IN, p, len + 1, "write_buf_line");
|
|
vim_free(p);
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if "channel" can be written to.
|
|
* Returns FALSE if the input is closed or the write would block.
|
|
*/
|
|
static int
|
|
can_write_buf_line(channel_T *channel)
|
|
{
|
|
chanpart_T *in_part = &channel->ch_part[PART_IN];
|
|
|
|
if (in_part->ch_fd == INVALID_FD)
|
|
return FALSE; /* pipe was closed */
|
|
|
|
/* for testing: block every other attempt to write */
|
|
if (in_part->ch_block_write == 1)
|
|
in_part->ch_block_write = -1;
|
|
else if (in_part->ch_block_write == -1)
|
|
in_part->ch_block_write = 1;
|
|
|
|
/* TODO: Win32 implementation, probably using WaitForMultipleObjects() */
|
|
#ifndef WIN32
|
|
{
|
|
# if defined(HAVE_SELECT)
|
|
struct timeval tval;
|
|
fd_set wfds;
|
|
int ret;
|
|
|
|
FD_ZERO(&wfds);
|
|
FD_SET((int)in_part->ch_fd, &wfds);
|
|
tval.tv_sec = 0;
|
|
tval.tv_usec = 0;
|
|
for (;;)
|
|
{
|
|
ret = select((int)in_part->ch_fd + 1, NULL, &wfds, NULL, &tval);
|
|
# ifdef EINTR
|
|
SOCK_ERRNO;
|
|
if (ret == -1 && errno == EINTR)
|
|
continue;
|
|
# endif
|
|
if (ret <= 0 || in_part->ch_block_write == 1)
|
|
{
|
|
if (ret > 0)
|
|
ch_log(channel, "FAKED Input not ready for writing");
|
|
else
|
|
ch_log(channel, "Input not ready for writing");
|
|
return FALSE;
|
|
}
|
|
break;
|
|
}
|
|
# else
|
|
struct pollfd fds;
|
|
|
|
fds.fd = in_part->ch_fd;
|
|
fds.events = POLLOUT;
|
|
if (poll(&fds, 1, 0) <= 0)
|
|
{
|
|
ch_log(channel, "Input not ready for writing");
|
|
return FALSE;
|
|
}
|
|
if (in_part->ch_block_write == 1)
|
|
{
|
|
ch_log(channel, "FAKED Input not ready for writing");
|
|
return FALSE;
|
|
}
|
|
# endif
|
|
}
|
|
#endif
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Write any lines to the input channel.
|
|
*/
|
|
static void
|
|
channel_write_in(channel_T *channel)
|
|
{
|
|
chanpart_T *in_part = &channel->ch_part[PART_IN];
|
|
linenr_T lnum;
|
|
buf_T *buf = in_part->ch_bufref.br_buf;
|
|
int written = 0;
|
|
|
|
if (buf == NULL || in_part->ch_buf_append)
|
|
return; /* no buffer or using appending */
|
|
if (!bufref_valid(&in_part->ch_bufref) || buf->b_ml.ml_mfp == NULL)
|
|
{
|
|
/* buffer was wiped out or unloaded */
|
|
in_part->ch_bufref.br_buf = NULL;
|
|
return;
|
|
}
|
|
|
|
for (lnum = in_part->ch_buf_top; lnum <= in_part->ch_buf_bot
|
|
&& lnum <= buf->b_ml.ml_line_count; ++lnum)
|
|
{
|
|
if (!can_write_buf_line(channel))
|
|
break;
|
|
write_buf_line(buf, lnum, channel);
|
|
++written;
|
|
}
|
|
|
|
if (written == 1)
|
|
ch_logn(channel, "written line %d to channel", (int)lnum - 1);
|
|
else if (written > 1)
|
|
ch_logn(channel, "written %d lines to channel", written);
|
|
|
|
in_part->ch_buf_top = lnum;
|
|
if (lnum > buf->b_ml.ml_line_count || lnum > in_part->ch_buf_bot)
|
|
{
|
|
/* Writing is done, no longer need the buffer. */
|
|
in_part->ch_bufref.br_buf = NULL;
|
|
ch_log(channel, "Finished writing all lines to channel");
|
|
|
|
/* Close the pipe/socket, so that the other side gets EOF. */
|
|
ch_close_part(channel, PART_IN);
|
|
}
|
|
else
|
|
ch_logn(channel, "Still %d more lines to write",
|
|
buf->b_ml.ml_line_count - lnum + 1);
|
|
}
|
|
|
|
/*
|
|
* Handle buffer "buf" being freed, remove it from any channels.
|
|
*/
|
|
void
|
|
channel_buffer_free(buf_T *buf)
|
|
{
|
|
channel_T *channel;
|
|
ch_part_T part;
|
|
|
|
for (channel = first_channel; channel != NULL; channel = channel->ch_next)
|
|
for (part = PART_SOCK; part < PART_COUNT; ++part)
|
|
{
|
|
chanpart_T *ch_part = &channel->ch_part[part];
|
|
|
|
if (ch_part->ch_bufref.br_buf == buf)
|
|
{
|
|
ch_logs(channel, "%s buffer has been wiped out",
|
|
part_names[part]);
|
|
ch_part->ch_bufref.br_buf = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Write any lines waiting to be written to a channel.
|
|
*/
|
|
void
|
|
channel_write_any_lines(void)
|
|
{
|
|
channel_T *channel;
|
|
|
|
for (channel = first_channel; channel != NULL; channel = channel->ch_next)
|
|
{
|
|
chanpart_T *in_part = &channel->ch_part[PART_IN];
|
|
|
|
if (in_part->ch_bufref.br_buf != NULL)
|
|
{
|
|
if (in_part->ch_buf_append)
|
|
channel_write_new_lines(in_part->ch_bufref.br_buf);
|
|
else
|
|
channel_write_in(channel);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Write appended lines above the last one in "buf" to the channel.
|
|
*/
|
|
void
|
|
channel_write_new_lines(buf_T *buf)
|
|
{
|
|
channel_T *channel;
|
|
int found_one = FALSE;
|
|
|
|
/* There could be more than one channel for the buffer, loop over all of
|
|
* them. */
|
|
for (channel = first_channel; channel != NULL; channel = channel->ch_next)
|
|
{
|
|
chanpart_T *in_part = &channel->ch_part[PART_IN];
|
|
linenr_T lnum;
|
|
int written = 0;
|
|
|
|
if (in_part->ch_bufref.br_buf == buf && in_part->ch_buf_append)
|
|
{
|
|
if (in_part->ch_fd == INVALID_FD)
|
|
continue; /* pipe was closed */
|
|
found_one = TRUE;
|
|
for (lnum = in_part->ch_buf_bot; lnum < buf->b_ml.ml_line_count;
|
|
++lnum)
|
|
{
|
|
if (!can_write_buf_line(channel))
|
|
break;
|
|
write_buf_line(buf, lnum, channel);
|
|
++written;
|
|
}
|
|
|
|
if (written == 1)
|
|
ch_logn(channel, "written line %d to channel", (int)lnum - 1);
|
|
else if (written > 1)
|
|
ch_logn(channel, "written %d lines to channel", written);
|
|
if (lnum < buf->b_ml.ml_line_count)
|
|
ch_logn(channel, "Still %d more lines to write",
|
|
buf->b_ml.ml_line_count - lnum);
|
|
|
|
in_part->ch_buf_bot = lnum;
|
|
}
|
|
}
|
|
if (!found_one)
|
|
buf->b_write_to_channel = FALSE;
|
|
}
|
|
|
|
/*
|
|
* Invoke the "callback" on channel "channel".
|
|
* This does not redraw but sets channel_need_redraw;
|
|
*/
|
|
static void
|
|
invoke_callback(channel_T *channel, char_u *callback, partial_T *partial,
|
|
typval_T *argv)
|
|
{
|
|
typval_T rettv;
|
|
int dummy;
|
|
|
|
if (safe_to_invoke_callback == 0)
|
|
IEMSG("INTERNAL: Invoking callback when it is not safe");
|
|
|
|
argv[0].v_type = VAR_CHANNEL;
|
|
argv[0].vval.v_channel = channel;
|
|
|
|
call_func(callback, (int)STRLEN(callback), &rettv, 2, argv, NULL,
|
|
0L, 0L, &dummy, TRUE, partial, NULL);
|
|
clear_tv(&rettv);
|
|
channel_need_redraw = TRUE;
|
|
}
|
|
|
|
/*
|
|
* Return the first node from "channel"/"part" without removing it.
|
|
* Returns NULL if there is nothing.
|
|
*/
|
|
readq_T *
|
|
channel_peek(channel_T *channel, ch_part_T part)
|
|
{
|
|
readq_T *head = &channel->ch_part[part].ch_head;
|
|
|
|
return head->rq_next;
|
|
}
|
|
|
|
/*
|
|
* Return a pointer to the first NL in "node".
|
|
* Skips over NUL characters.
|
|
* Returns NULL if there is no NL.
|
|
*/
|
|
char_u *
|
|
channel_first_nl(readq_T *node)
|
|
{
|
|
char_u *buffer = node->rq_buffer;
|
|
long_u i;
|
|
|
|
for (i = 0; i < node->rq_buflen; ++i)
|
|
if (buffer[i] == NL)
|
|
return buffer + i;
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Return the first buffer from channel "channel"/"part" and remove it.
|
|
* The caller must free it.
|
|
* Returns NULL if there is nothing.
|
|
*/
|
|
char_u *
|
|
channel_get(channel_T *channel, ch_part_T part)
|
|
{
|
|
readq_T *head = &channel->ch_part[part].ch_head;
|
|
readq_T *node = head->rq_next;
|
|
char_u *p;
|
|
|
|
if (node == NULL)
|
|
return NULL;
|
|
/* dispose of the node but keep the buffer */
|
|
p = node->rq_buffer;
|
|
head->rq_next = node->rq_next;
|
|
if (node->rq_next == NULL)
|
|
head->rq_prev = NULL;
|
|
else
|
|
node->rq_next->rq_prev = NULL;
|
|
vim_free(node);
|
|
return p;
|
|
}
|
|
|
|
/*
|
|
* Returns the whole buffer contents concatenated for "channel"/"part".
|
|
* Replaces NUL bytes with NL.
|
|
*/
|
|
static char_u *
|
|
channel_get_all(channel_T *channel, ch_part_T part)
|
|
{
|
|
readq_T *head = &channel->ch_part[part].ch_head;
|
|
readq_T *node = head->rq_next;
|
|
long_u len = 0;
|
|
char_u *res;
|
|
char_u *p;
|
|
|
|
/* If there is only one buffer just get that one. */
|
|
if (head->rq_next == NULL || head->rq_next->rq_next == NULL)
|
|
return channel_get(channel, part);
|
|
|
|
/* Concatenate everything into one buffer. */
|
|
for (node = head->rq_next; node != NULL; node = node->rq_next)
|
|
len += node->rq_buflen;
|
|
res = lalloc(len + 1, TRUE);
|
|
if (res == NULL)
|
|
return NULL;
|
|
p = res;
|
|
for (node = head->rq_next; node != NULL; node = node->rq_next)
|
|
{
|
|
mch_memmove(p, node->rq_buffer, node->rq_buflen);
|
|
p += node->rq_buflen;
|
|
}
|
|
*p = NUL;
|
|
|
|
/* Free all buffers */
|
|
do
|
|
{
|
|
p = channel_get(channel, part);
|
|
vim_free(p);
|
|
} while (p != NULL);
|
|
|
|
/* turn all NUL into NL */
|
|
while (len > 0)
|
|
{
|
|
--len;
|
|
if (res[len] == NUL)
|
|
res[len] = NL;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
* Consume "len" bytes from the head of "node".
|
|
* Caller must check these bytes are available.
|
|
*/
|
|
void
|
|
channel_consume(channel_T *channel, ch_part_T part, int len)
|
|
{
|
|
readq_T *head = &channel->ch_part[part].ch_head;
|
|
readq_T *node = head->rq_next;
|
|
char_u *buf = node->rq_buffer;
|
|
|
|
mch_memmove(buf, buf + len, node->rq_buflen - len);
|
|
node->rq_buflen -= len;
|
|
}
|
|
|
|
/*
|
|
* Collapses the first and second buffer for "channel"/"part".
|
|
* Returns FAIL if that is not possible.
|
|
* When "want_nl" is TRUE collapse more buffers until a NL is found.
|
|
*/
|
|
int
|
|
channel_collapse(channel_T *channel, ch_part_T part, int want_nl)
|
|
{
|
|
readq_T *head = &channel->ch_part[part].ch_head;
|
|
readq_T *node = head->rq_next;
|
|
readq_T *last_node;
|
|
readq_T *n;
|
|
char_u *newbuf;
|
|
char_u *p;
|
|
long_u len;
|
|
|
|
if (node == NULL || node->rq_next == NULL)
|
|
return FAIL;
|
|
|
|
last_node = node->rq_next;
|
|
len = node->rq_buflen + last_node->rq_buflen + 1;
|
|
if (want_nl)
|
|
while (last_node->rq_next != NULL
|
|
&& channel_first_nl(last_node) == NULL)
|
|
{
|
|
last_node = last_node->rq_next;
|
|
len += last_node->rq_buflen;
|
|
}
|
|
|
|
p = newbuf = alloc(len);
|
|
if (newbuf == NULL)
|
|
return FAIL; /* out of memory */
|
|
mch_memmove(p, node->rq_buffer, node->rq_buflen);
|
|
p += node->rq_buflen;
|
|
vim_free(node->rq_buffer);
|
|
node->rq_buffer = newbuf;
|
|
for (n = node; n != last_node; )
|
|
{
|
|
n = n->rq_next;
|
|
mch_memmove(p, n->rq_buffer, n->rq_buflen);
|
|
p += n->rq_buflen;
|
|
vim_free(n->rq_buffer);
|
|
}
|
|
node->rq_buflen = (long_u)(p - newbuf);
|
|
|
|
/* dispose of the collapsed nodes and their buffers */
|
|
for (n = node->rq_next; n != last_node; )
|
|
{
|
|
n = n->rq_next;
|
|
vim_free(n->rq_prev);
|
|
}
|
|
node->rq_next = last_node->rq_next;
|
|
if (last_node->rq_next == NULL)
|
|
head->rq_prev = node;
|
|
else
|
|
last_node->rq_next->rq_prev = node;
|
|
vim_free(last_node);
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* Store "buf[len]" on "channel"/"part".
|
|
* When "prepend" is TRUE put in front, otherwise append at the end.
|
|
* Returns OK or FAIL.
|
|
*/
|
|
static int
|
|
channel_save(channel_T *channel, ch_part_T part, char_u *buf, int len,
|
|
int prepend, char *lead)
|
|
{
|
|
readq_T *node;
|
|
readq_T *head = &channel->ch_part[part].ch_head;
|
|
char_u *p;
|
|
int i;
|
|
|
|
node = (readq_T *)alloc(sizeof(readq_T));
|
|
if (node == NULL)
|
|
return FAIL; /* out of memory */
|
|
/* A NUL is added at the end, because netbeans code expects that.
|
|
* Otherwise a NUL may appear inside the text. */
|
|
node->rq_buffer = alloc(len + 1);
|
|
if (node->rq_buffer == NULL)
|
|
{
|
|
vim_free(node);
|
|
return FAIL; /* out of memory */
|
|
}
|
|
|
|
if (channel->ch_part[part].ch_mode == MODE_NL)
|
|
{
|
|
/* Drop any CR before a NL. */
|
|
p = node->rq_buffer;
|
|
for (i = 0; i < len; ++i)
|
|
if (buf[i] != CAR || i + 1 >= len || buf[i + 1] != NL)
|
|
*p++ = buf[i];
|
|
*p = NUL;
|
|
node->rq_buflen = (long_u)(p - node->rq_buffer);
|
|
}
|
|
else
|
|
{
|
|
mch_memmove(node->rq_buffer, buf, len);
|
|
node->rq_buffer[len] = NUL;
|
|
node->rq_buflen = (long_u)len;
|
|
}
|
|
|
|
if (prepend)
|
|
{
|
|
/* preend node to the head of the queue */
|
|
node->rq_next = head->rq_next;
|
|
node->rq_prev = NULL;
|
|
if (head->rq_next == NULL)
|
|
head->rq_prev = node;
|
|
else
|
|
head->rq_next->rq_prev = node;
|
|
head->rq_next = node;
|
|
}
|
|
else
|
|
{
|
|
/* append node to the tail of the queue */
|
|
node->rq_next = NULL;
|
|
node->rq_prev = head->rq_prev;
|
|
if (head->rq_prev == NULL)
|
|
head->rq_next = node;
|
|
else
|
|
head->rq_prev->rq_next = node;
|
|
head->rq_prev = node;
|
|
}
|
|
|
|
if (log_fd != NULL && lead != NULL)
|
|
{
|
|
ch_log_lead(lead, channel);
|
|
fprintf(log_fd, "'");
|
|
if (fwrite(buf, len, 1, log_fd) != 1)
|
|
return FAIL;
|
|
fprintf(log_fd, "'\n");
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* Try to fill the buffer of "reader".
|
|
* Returns FALSE when nothing was added.
|
|
*/
|
|
static int
|
|
channel_fill(js_read_T *reader)
|
|
{
|
|
channel_T *channel = (channel_T *)reader->js_cookie;
|
|
ch_part_T part = reader->js_cookie_arg;
|
|
char_u *next = channel_get(channel, part);
|
|
int keeplen;
|
|
int addlen;
|
|
char_u *p;
|
|
|
|
if (next == NULL)
|
|
return FALSE;
|
|
|
|
keeplen = reader->js_end - reader->js_buf;
|
|
if (keeplen > 0)
|
|
{
|
|
/* Prepend unused text. */
|
|
addlen = (int)STRLEN(next);
|
|
p = alloc(keeplen + addlen + 1);
|
|
if (p == NULL)
|
|
{
|
|
vim_free(next);
|
|
return FALSE;
|
|
}
|
|
mch_memmove(p, reader->js_buf, keeplen);
|
|
mch_memmove(p + keeplen, next, addlen + 1);
|
|
vim_free(next);
|
|
next = p;
|
|
}
|
|
|
|
vim_free(reader->js_buf);
|
|
reader->js_buf = next;
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Use the read buffer of "channel"/"part" and parse a JSON message that is
|
|
* complete. The messages are added to the queue.
|
|
* Return TRUE if there is more to read.
|
|
*/
|
|
static int
|
|
channel_parse_json(channel_T *channel, ch_part_T part)
|
|
{
|
|
js_read_T reader;
|
|
typval_T listtv;
|
|
jsonq_T *item;
|
|
chanpart_T *chanpart = &channel->ch_part[part];
|
|
jsonq_T *head = &chanpart->ch_json_head;
|
|
int status;
|
|
int ret;
|
|
|
|
if (channel_peek(channel, part) == NULL)
|
|
return FALSE;
|
|
|
|
reader.js_buf = channel_get(channel, part);
|
|
reader.js_used = 0;
|
|
reader.js_fill = channel_fill;
|
|
reader.js_cookie = channel;
|
|
reader.js_cookie_arg = part;
|
|
|
|
/* When a message is incomplete we wait for a short while for more to
|
|
* arrive. After the delay drop the input, otherwise a truncated string
|
|
* or list will make us hang.
|
|
* Do not generate error messages, they will be written in a channel log. */
|
|
++emsg_silent;
|
|
status = json_decode(&reader, &listtv,
|
|
chanpart->ch_mode == MODE_JS ? JSON_JS : 0);
|
|
--emsg_silent;
|
|
if (status == OK)
|
|
{
|
|
/* Only accept the response when it is a list with at least two
|
|
* items. */
|
|
if (listtv.v_type != VAR_LIST || listtv.vval.v_list->lv_len < 2)
|
|
{
|
|
if (listtv.v_type != VAR_LIST)
|
|
ch_error(channel, "Did not receive a list, discarding");
|
|
else
|
|
ch_errorn(channel, "Expected list with two items, got %d",
|
|
listtv.vval.v_list->lv_len);
|
|
clear_tv(&listtv);
|
|
}
|
|
else
|
|
{
|
|
item = (jsonq_T *)alloc((unsigned)sizeof(jsonq_T));
|
|
if (item == NULL)
|
|
clear_tv(&listtv);
|
|
else
|
|
{
|
|
item->jq_no_callback = FALSE;
|
|
item->jq_value = alloc_tv();
|
|
if (item->jq_value == NULL)
|
|
{
|
|
vim_free(item);
|
|
clear_tv(&listtv);
|
|
}
|
|
else
|
|
{
|
|
*item->jq_value = listtv;
|
|
item->jq_prev = head->jq_prev;
|
|
head->jq_prev = item;
|
|
item->jq_next = NULL;
|
|
if (item->jq_prev == NULL)
|
|
head->jq_next = item;
|
|
else
|
|
item->jq_prev->jq_next = item;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (status == OK)
|
|
chanpart->ch_wait_len = 0;
|
|
else if (status == MAYBE)
|
|
{
|
|
size_t buflen = STRLEN(reader.js_buf);
|
|
|
|
if (chanpart->ch_wait_len < buflen)
|
|
{
|
|
/* First time encountering incomplete message or after receiving
|
|
* more (but still incomplete): set a deadline of 100 msec. */
|
|
ch_logn(channel,
|
|
"Incomplete message (%d bytes) - wait 100 msec for more",
|
|
(int)buflen);
|
|
reader.js_used = 0;
|
|
chanpart->ch_wait_len = buflen;
|
|
#ifdef WIN32
|
|
chanpart->ch_deadline = GetTickCount() + 100L;
|
|
#else
|
|
gettimeofday(&chanpart->ch_deadline, NULL);
|
|
chanpart->ch_deadline.tv_usec += 100 * 1000;
|
|
if (chanpart->ch_deadline.tv_usec > 1000 * 1000)
|
|
{
|
|
chanpart->ch_deadline.tv_usec -= 1000 * 1000;
|
|
++chanpart->ch_deadline.tv_sec;
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
int timeout;
|
|
#ifdef WIN32
|
|
timeout = GetTickCount() > chanpart->ch_deadline;
|
|
#else
|
|
{
|
|
struct timeval now_tv;
|
|
|
|
gettimeofday(&now_tv, NULL);
|
|
timeout = now_tv.tv_sec > chanpart->ch_deadline.tv_sec
|
|
|| (now_tv.tv_sec == chanpart->ch_deadline.tv_sec
|
|
&& now_tv.tv_usec > chanpart->ch_deadline.tv_usec);
|
|
}
|
|
#endif
|
|
if (timeout)
|
|
{
|
|
status = FAIL;
|
|
chanpart->ch_wait_len = 0;
|
|
ch_log(channel, "timed out");
|
|
}
|
|
else
|
|
{
|
|
reader.js_used = 0;
|
|
ch_log(channel, "still waiting on incomplete message");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (status == FAIL)
|
|
{
|
|
ch_error(channel, "Decoding failed - discarding input");
|
|
ret = FALSE;
|
|
chanpart->ch_wait_len = 0;
|
|
}
|
|
else if (reader.js_buf[reader.js_used] != NUL)
|
|
{
|
|
/* Put the unread part back into the channel. */
|
|
channel_save(channel, part, reader.js_buf + reader.js_used,
|
|
(int)(reader.js_end - reader.js_buf) - reader.js_used,
|
|
TRUE, NULL);
|
|
ret = status == MAYBE ? FALSE: TRUE;
|
|
}
|
|
else
|
|
ret = FALSE;
|
|
|
|
vim_free(reader.js_buf);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Remove "node" from the queue that it is in. Does not free it.
|
|
*/
|
|
static void
|
|
remove_cb_node(cbq_T *head, cbq_T *node)
|
|
{
|
|
if (node->cq_prev == NULL)
|
|
head->cq_next = node->cq_next;
|
|
else
|
|
node->cq_prev->cq_next = node->cq_next;
|
|
if (node->cq_next == NULL)
|
|
head->cq_prev = node->cq_prev;
|
|
else
|
|
node->cq_next->cq_prev = node->cq_prev;
|
|
}
|
|
|
|
/*
|
|
* Remove "node" from the queue that it is in and free it.
|
|
* Caller should have freed or used node->jq_value.
|
|
*/
|
|
static void
|
|
remove_json_node(jsonq_T *head, jsonq_T *node)
|
|
{
|
|
if (node->jq_prev == NULL)
|
|
head->jq_next = node->jq_next;
|
|
else
|
|
node->jq_prev->jq_next = node->jq_next;
|
|
if (node->jq_next == NULL)
|
|
head->jq_prev = node->jq_prev;
|
|
else
|
|
node->jq_next->jq_prev = node->jq_prev;
|
|
vim_free(node);
|
|
}
|
|
|
|
/*
|
|
* Get a message from the JSON queue for channel "channel".
|
|
* When "id" is positive it must match the first number in the list.
|
|
* When "id" is zero or negative jut get the first message. But not the one
|
|
* with id ch_block_id.
|
|
* When "without_callback" is TRUE also get messages that were pushed back.
|
|
* Return OK when found and return the value in "rettv".
|
|
* Return FAIL otherwise.
|
|
*/
|
|
static int
|
|
channel_get_json(
|
|
channel_T *channel,
|
|
ch_part_T part,
|
|
int id,
|
|
int without_callback,
|
|
typval_T **rettv)
|
|
{
|
|
jsonq_T *head = &channel->ch_part[part].ch_json_head;
|
|
jsonq_T *item = head->jq_next;
|
|
|
|
while (item != NULL)
|
|
{
|
|
list_T *l = item->jq_value->vval.v_list;
|
|
typval_T *tv = &l->lv_first->li_tv;
|
|
|
|
if ((without_callback || !item->jq_no_callback)
|
|
&& ((id > 0 && tv->v_type == VAR_NUMBER && tv->vval.v_number == id)
|
|
|| (id <= 0 && (tv->v_type != VAR_NUMBER
|
|
|| tv->vval.v_number == 0
|
|
|| tv->vval.v_number != channel->ch_part[part].ch_block_id))))
|
|
{
|
|
*rettv = item->jq_value;
|
|
if (tv->v_type == VAR_NUMBER)
|
|
ch_logn(channel, "Getting JSON message %d", tv->vval.v_number);
|
|
remove_json_node(head, item);
|
|
return OK;
|
|
}
|
|
item = item->jq_next;
|
|
}
|
|
return FAIL;
|
|
}
|
|
|
|
/*
|
|
* Put back "rettv" into the JSON queue, there was no callback for it.
|
|
* Takes over the values in "rettv".
|
|
*/
|
|
static void
|
|
channel_push_json(channel_T *channel, ch_part_T part, typval_T *rettv)
|
|
{
|
|
jsonq_T *head = &channel->ch_part[part].ch_json_head;
|
|
jsonq_T *item = head->jq_next;
|
|
jsonq_T *newitem;
|
|
|
|
if (head->jq_prev != NULL && head->jq_prev->jq_no_callback)
|
|
/* last item was pushed back, append to the end */
|
|
item = NULL;
|
|
else while (item != NULL && item->jq_no_callback)
|
|
/* append after the last item that was pushed back */
|
|
item = item->jq_next;
|
|
|
|
newitem = (jsonq_T *)alloc((unsigned)sizeof(jsonq_T));
|
|
if (newitem == NULL)
|
|
clear_tv(rettv);
|
|
else
|
|
{
|
|
newitem->jq_value = alloc_tv();
|
|
if (newitem->jq_value == NULL)
|
|
{
|
|
vim_free(newitem);
|
|
clear_tv(rettv);
|
|
}
|
|
else
|
|
{
|
|
newitem->jq_no_callback = FALSE;
|
|
*newitem->jq_value = *rettv;
|
|
if (item == NULL)
|
|
{
|
|
/* append to the end */
|
|
newitem->jq_prev = head->jq_prev;
|
|
head->jq_prev = newitem;
|
|
newitem->jq_next = NULL;
|
|
if (newitem->jq_prev == NULL)
|
|
head->jq_next = newitem;
|
|
else
|
|
newitem->jq_prev->jq_next = newitem;
|
|
}
|
|
else
|
|
{
|
|
/* append after "item" */
|
|
newitem->jq_prev = item;
|
|
newitem->jq_next = item->jq_next;
|
|
item->jq_next = newitem;
|
|
if (newitem->jq_next == NULL)
|
|
head->jq_prev = newitem;
|
|
else
|
|
newitem->jq_next->jq_prev = newitem;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#define CH_JSON_MAX_ARGS 4
|
|
|
|
/*
|
|
* Execute a command received over "channel"/"part"
|
|
* "argv[0]" is the command string.
|
|
* "argv[1]" etc. have further arguments, type is VAR_UNKNOWN if missing.
|
|
*/
|
|
static void
|
|
channel_exe_cmd(channel_T *channel, ch_part_T part, typval_T *argv)
|
|
{
|
|
char_u *cmd = argv[0].vval.v_string;
|
|
char_u *arg;
|
|
int options = channel->ch_part[part].ch_mode == MODE_JS ? JSON_JS : 0;
|
|
|
|
if (argv[1].v_type != VAR_STRING)
|
|
{
|
|
ch_error(channel, "received command with non-string argument");
|
|
if (p_verbose > 2)
|
|
EMSG(_("E903: received command with non-string argument"));
|
|
return;
|
|
}
|
|
arg = argv[1].vval.v_string;
|
|
if (arg == NULL)
|
|
arg = (char_u *)"";
|
|
|
|
if (STRCMP(cmd, "ex") == 0)
|
|
{
|
|
int save_called_emsg = called_emsg;
|
|
|
|
called_emsg = FALSE;
|
|
ch_logs(channel, "Executing ex command '%s'", (char *)arg);
|
|
++emsg_silent;
|
|
do_cmdline_cmd(arg);
|
|
--emsg_silent;
|
|
if (called_emsg)
|
|
ch_logs(channel, "Ex command error: '%s'",
|
|
(char *)get_vim_var_str(VV_ERRMSG));
|
|
called_emsg = save_called_emsg;
|
|
}
|
|
else if (STRCMP(cmd, "normal") == 0)
|
|
{
|
|
exarg_T ea;
|
|
|
|
ch_logs(channel, "Executing normal command '%s'", (char *)arg);
|
|
ea.arg = arg;
|
|
ea.addr_count = 0;
|
|
ea.forceit = TRUE; /* no mapping */
|
|
ex_normal(&ea);
|
|
}
|
|
else if (STRCMP(cmd, "redraw") == 0)
|
|
{
|
|
exarg_T ea;
|
|
|
|
ch_log(channel, "redraw");
|
|
ea.forceit = *arg != NUL;
|
|
ex_redraw(&ea);
|
|
showruler(FALSE);
|
|
setcursor();
|
|
out_flush();
|
|
#ifdef FEAT_GUI
|
|
if (gui.in_use)
|
|
{
|
|
gui_update_cursor(TRUE, FALSE);
|
|
gui_mch_flush();
|
|
}
|
|
#endif
|
|
}
|
|
else if (STRCMP(cmd, "expr") == 0 || STRCMP(cmd, "call") == 0)
|
|
{
|
|
int is_call = cmd[0] == 'c';
|
|
int id_idx = is_call ? 3 : 2;
|
|
|
|
if (argv[id_idx].v_type != VAR_UNKNOWN
|
|
&& argv[id_idx].v_type != VAR_NUMBER)
|
|
{
|
|
ch_error(channel, "last argument for expr/call must be a number");
|
|
if (p_verbose > 2)
|
|
EMSG(_("E904: last argument for expr/call must be a number"));
|
|
}
|
|
else if (is_call && argv[2].v_type != VAR_LIST)
|
|
{
|
|
ch_error(channel, "third argument for call must be a list");
|
|
if (p_verbose > 2)
|
|
EMSG(_("E904: third argument for call must be a list"));
|
|
}
|
|
else
|
|
{
|
|
typval_T *tv = NULL;
|
|
typval_T res_tv;
|
|
typval_T err_tv;
|
|
char_u *json = NULL;
|
|
|
|
/* Don't pollute the display with errors. */
|
|
++emsg_skip;
|
|
if (!is_call)
|
|
{
|
|
ch_logs(channel, "Evaluating expression '%s'", (char *)arg);
|
|
tv = eval_expr(arg, NULL);
|
|
}
|
|
else
|
|
{
|
|
ch_logs(channel, "Calling '%s'", (char *)arg);
|
|
if (func_call(arg, &argv[2], NULL, NULL, &res_tv) == OK)
|
|
tv = &res_tv;
|
|
}
|
|
|
|
if (argv[id_idx].v_type == VAR_NUMBER)
|
|
{
|
|
int id = argv[id_idx].vval.v_number;
|
|
|
|
if (tv != NULL)
|
|
json = json_encode_nr_expr(id, tv, options | JSON_NL);
|
|
if (tv == NULL || (json != NULL && *json == NUL))
|
|
{
|
|
/* If evaluation failed or the result can't be encoded
|
|
* then return the string "ERROR". */
|
|
vim_free(json);
|
|
err_tv.v_type = VAR_STRING;
|
|
err_tv.vval.v_string = (char_u *)"ERROR";
|
|
json = json_encode_nr_expr(id, &err_tv, options | JSON_NL);
|
|
}
|
|
if (json != NULL)
|
|
{
|
|
channel_send(channel,
|
|
part == PART_SOCK ? PART_SOCK : PART_IN,
|
|
json, (int)STRLEN(json), (char *)cmd);
|
|
vim_free(json);
|
|
}
|
|
}
|
|
--emsg_skip;
|
|
if (tv == &res_tv)
|
|
clear_tv(tv);
|
|
else
|
|
free_tv(tv);
|
|
}
|
|
}
|
|
else if (p_verbose > 2)
|
|
{
|
|
ch_errors(channel, "Received unknown command: %s", (char *)cmd);
|
|
EMSG2(_("E905: received unknown command: %s"), cmd);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Invoke the callback at "cbhead".
|
|
* Does not redraw but sets channel_need_redraw.
|
|
*/
|
|
static void
|
|
invoke_one_time_callback(
|
|
channel_T *channel,
|
|
cbq_T *cbhead,
|
|
cbq_T *item,
|
|
typval_T *argv)
|
|
{
|
|
ch_logs(channel, "Invoking one-time callback %s",
|
|
(char *)item->cq_callback);
|
|
/* Remove the item from the list first, if the callback
|
|
* invokes ch_close() the list will be cleared. */
|
|
remove_cb_node(cbhead, item);
|
|
invoke_callback(channel, item->cq_callback, item->cq_partial, argv);
|
|
free_callback(item->cq_callback, item->cq_partial);
|
|
vim_free(item);
|
|
}
|
|
|
|
static void
|
|
append_to_buffer(buf_T *buffer, char_u *msg, channel_T *channel, ch_part_T part)
|
|
{
|
|
buf_T *save_curbuf = curbuf;
|
|
linenr_T lnum = buffer->b_ml.ml_line_count;
|
|
int save_write_to = buffer->b_write_to_channel;
|
|
chanpart_T *ch_part = &channel->ch_part[part];
|
|
int save_p_ma = buffer->b_p_ma;
|
|
int empty = (buffer->b_ml.ml_flags & ML_EMPTY);
|
|
|
|
if (!buffer->b_p_ma && !ch_part->ch_nomodifiable)
|
|
{
|
|
if (!ch_part->ch_nomod_error)
|
|
{
|
|
ch_error(channel, "Buffer is not modifiable, cannot append");
|
|
ch_part->ch_nomod_error = TRUE;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* If the buffer is also used as input insert above the last
|
|
* line. Don't write these lines. */
|
|
if (save_write_to)
|
|
{
|
|
--lnum;
|
|
buffer->b_write_to_channel = FALSE;
|
|
}
|
|
|
|
/* Append to the buffer */
|
|
ch_logn(channel, "appending line %d to buffer", (int)lnum + 1);
|
|
|
|
buffer->b_p_ma = TRUE;
|
|
curbuf = buffer;
|
|
u_sync(TRUE);
|
|
/* ignore undo failure, undo is not very useful here */
|
|
ignored = u_save(lnum, lnum + 1 + (empty ? 1 : 0));
|
|
|
|
if (empty)
|
|
{
|
|
/* The buffer is empty, replace the first (dummy) line. */
|
|
ml_replace(lnum, msg, TRUE);
|
|
lnum = 0;
|
|
}
|
|
else
|
|
ml_append(lnum, msg, 0, FALSE);
|
|
appended_lines_mark(lnum, 1L);
|
|
curbuf = save_curbuf;
|
|
if (ch_part->ch_nomodifiable)
|
|
buffer->b_p_ma = FALSE;
|
|
else
|
|
buffer->b_p_ma = save_p_ma;
|
|
|
|
if (buffer->b_nwindows > 0)
|
|
{
|
|
win_T *wp;
|
|
win_T *save_curwin;
|
|
|
|
FOR_ALL_WINDOWS(wp)
|
|
{
|
|
if (wp->w_buffer == buffer
|
|
&& (save_write_to
|
|
? wp->w_cursor.lnum == lnum + 1
|
|
: (wp->w_cursor.lnum == lnum
|
|
&& wp->w_cursor.col == 0)))
|
|
{
|
|
++wp->w_cursor.lnum;
|
|
save_curwin = curwin;
|
|
curwin = wp;
|
|
curbuf = curwin->w_buffer;
|
|
scroll_cursor_bot(0, FALSE);
|
|
curwin = save_curwin;
|
|
curbuf = curwin->w_buffer;
|
|
}
|
|
}
|
|
redraw_buf_later(buffer, VALID);
|
|
channel_need_redraw = TRUE;
|
|
}
|
|
|
|
if (save_write_to)
|
|
{
|
|
channel_T *ch;
|
|
|
|
/* Find channels reading from this buffer and adjust their
|
|
* next-to-read line number. */
|
|
buffer->b_write_to_channel = TRUE;
|
|
for (ch = first_channel; ch != NULL; ch = ch->ch_next)
|
|
{
|
|
chanpart_T *in_part = &ch->ch_part[PART_IN];
|
|
|
|
if (in_part->ch_bufref.br_buf == buffer)
|
|
in_part->ch_buf_bot = buffer->b_ml.ml_line_count;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
drop_messages(channel_T *channel, ch_part_T part)
|
|
{
|
|
char_u *msg;
|
|
|
|
while ((msg = channel_get(channel, part)) != NULL)
|
|
{
|
|
ch_logs(channel, "Dropping message '%s'", (char *)msg);
|
|
vim_free(msg);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Invoke a callback for "channel"/"part" if needed.
|
|
* This does not redraw but sets channel_need_redraw when redraw is needed.
|
|
* Return TRUE when a message was handled, there might be another one.
|
|
*/
|
|
static int
|
|
may_invoke_callback(channel_T *channel, ch_part_T part)
|
|
{
|
|
char_u *msg = NULL;
|
|
typval_T *listtv = NULL;
|
|
typval_T argv[CH_JSON_MAX_ARGS];
|
|
int seq_nr = -1;
|
|
chanpart_T *ch_part = &channel->ch_part[part];
|
|
ch_mode_T ch_mode = ch_part->ch_mode;
|
|
cbq_T *cbhead = &ch_part->ch_cb_head;
|
|
cbq_T *cbitem;
|
|
char_u *callback = NULL;
|
|
partial_T *partial = NULL;
|
|
buf_T *buffer = NULL;
|
|
char_u *p;
|
|
|
|
if (channel->ch_nb_close_cb != NULL)
|
|
/* this channel is handled elsewhere (netbeans) */
|
|
return FALSE;
|
|
|
|
/* Use a message-specific callback, part callback or channel callback */
|
|
for (cbitem = cbhead->cq_next; cbitem != NULL; cbitem = cbitem->cq_next)
|
|
if (cbitem->cq_seq_nr == 0)
|
|
break;
|
|
if (cbitem != NULL)
|
|
{
|
|
callback = cbitem->cq_callback;
|
|
partial = cbitem->cq_partial;
|
|
}
|
|
else if (ch_part->ch_callback != NULL)
|
|
{
|
|
callback = ch_part->ch_callback;
|
|
partial = ch_part->ch_partial;
|
|
}
|
|
else
|
|
{
|
|
callback = channel->ch_callback;
|
|
partial = channel->ch_partial;
|
|
}
|
|
|
|
buffer = ch_part->ch_bufref.br_buf;
|
|
if (buffer != NULL && !bufref_valid(&ch_part->ch_bufref))
|
|
{
|
|
/* buffer was wiped out */
|
|
ch_part->ch_bufref.br_buf = NULL;
|
|
buffer = NULL;
|
|
}
|
|
|
|
if (ch_mode == MODE_JSON || ch_mode == MODE_JS)
|
|
{
|
|
listitem_T *item;
|
|
int argc = 0;
|
|
|
|
/* Get any json message in the queue. */
|
|
if (channel_get_json(channel, part, -1, FALSE, &listtv) == FAIL)
|
|
{
|
|
/* Parse readahead, return when there is still no message. */
|
|
channel_parse_json(channel, part);
|
|
if (channel_get_json(channel, part, -1, FALSE, &listtv) == FAIL)
|
|
return FALSE;
|
|
}
|
|
|
|
for (item = listtv->vval.v_list->lv_first;
|
|
item != NULL && argc < CH_JSON_MAX_ARGS;
|
|
item = item->li_next)
|
|
argv[argc++] = item->li_tv;
|
|
while (argc < CH_JSON_MAX_ARGS)
|
|
argv[argc++].v_type = VAR_UNKNOWN;
|
|
|
|
if (argv[0].v_type == VAR_STRING)
|
|
{
|
|
/* ["cmd", arg] or ["cmd", arg, arg] or ["cmd", arg, arg, arg] */
|
|
channel_exe_cmd(channel, part, argv);
|
|
free_tv(listtv);
|
|
return TRUE;
|
|
}
|
|
|
|
if (argv[0].v_type != VAR_NUMBER)
|
|
{
|
|
ch_error(channel,
|
|
"Dropping message with invalid sequence number type");
|
|
free_tv(listtv);
|
|
return FALSE;
|
|
}
|
|
seq_nr = argv[0].vval.v_number;
|
|
}
|
|
else if (channel_peek(channel, part) == NULL)
|
|
{
|
|
/* nothing to read on RAW or NL channel */
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
/* If there is no callback or buffer drop the message. */
|
|
if (callback == NULL && buffer == NULL)
|
|
{
|
|
/* If there is a close callback it may use ch_read() to get the
|
|
* messages. */
|
|
if (channel->ch_close_cb == NULL && !channel->ch_drop_never)
|
|
drop_messages(channel, part);
|
|
return FALSE;
|
|
}
|
|
|
|
if (ch_mode == MODE_NL)
|
|
{
|
|
char_u *nl = NULL;
|
|
char_u *buf;
|
|
readq_T *node;
|
|
|
|
/* See if we have a message ending in NL in the first buffer. If
|
|
* not try to concatenate the first and the second buffer. */
|
|
while (TRUE)
|
|
{
|
|
node = channel_peek(channel, part);
|
|
nl = channel_first_nl(node);
|
|
if (nl != NULL)
|
|
break;
|
|
if (channel_collapse(channel, part, TRUE) == FAIL)
|
|
{
|
|
if (ch_part->ch_fd == INVALID_FD && node->rq_buflen > 0)
|
|
break;
|
|
return FALSE; /* incomplete message */
|
|
}
|
|
}
|
|
buf = node->rq_buffer;
|
|
|
|
if (nl == NULL)
|
|
{
|
|
/* Flush remaining message that is missing a NL. */
|
|
char_u *new_buf;
|
|
|
|
new_buf = vim_realloc(buf, node->rq_buflen + 1);
|
|
if (new_buf == NULL)
|
|
/* This might fail over and over again, should the message
|
|
* be dropped? */
|
|
return FALSE;
|
|
buf = new_buf;
|
|
node->rq_buffer = buf;
|
|
nl = buf + node->rq_buflen++;
|
|
*nl = NUL;
|
|
}
|
|
|
|
/* Convert NUL to NL, the internal representation. */
|
|
for (p = buf; p < nl && p < buf + node->rq_buflen; ++p)
|
|
if (*p == NUL)
|
|
*p = NL;
|
|
|
|
if (nl + 1 == buf + node->rq_buflen)
|
|
{
|
|
/* get the whole buffer, drop the NL */
|
|
msg = channel_get(channel, part);
|
|
*nl = NUL;
|
|
}
|
|
else
|
|
{
|
|
/* Copy the message into allocated memory (excluding the NL)
|
|
* and remove it from the buffer (including the NL). */
|
|
msg = vim_strnsave(buf, (int)(nl - buf));
|
|
channel_consume(channel, part, (int)(nl - buf) + 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* For a raw channel we don't know where the message ends, just
|
|
* get everything we have.
|
|
* Convert NUL to NL, the internal representation. */
|
|
msg = channel_get_all(channel, part);
|
|
}
|
|
|
|
if (msg == NULL)
|
|
return FALSE; /* out of memory (and avoids Coverity warning) */
|
|
|
|
argv[1].v_type = VAR_STRING;
|
|
argv[1].vval.v_string = msg;
|
|
}
|
|
|
|
if (seq_nr > 0)
|
|
{
|
|
int done = FALSE;
|
|
|
|
/* JSON or JS mode: invoke the one-time callback with the matching nr */
|
|
for (cbitem = cbhead->cq_next; cbitem != NULL; cbitem = cbitem->cq_next)
|
|
if (cbitem->cq_seq_nr == seq_nr)
|
|
{
|
|
invoke_one_time_callback(channel, cbhead, cbitem, argv);
|
|
done = TRUE;
|
|
break;
|
|
}
|
|
if (!done)
|
|
{
|
|
if (channel->ch_drop_never)
|
|
{
|
|
/* message must be read with ch_read() */
|
|
channel_push_json(channel, part, listtv);
|
|
listtv = NULL;
|
|
}
|
|
else
|
|
ch_logn(channel, "Dropping message %d without callback",
|
|
seq_nr);
|
|
}
|
|
}
|
|
else if (callback != NULL || buffer != NULL)
|
|
{
|
|
if (buffer != NULL)
|
|
{
|
|
if (msg == NULL)
|
|
/* JSON or JS mode: re-encode the message. */
|
|
msg = json_encode(listtv, ch_mode);
|
|
if (msg != NULL)
|
|
append_to_buffer(buffer, msg, channel, part);
|
|
}
|
|
|
|
if (callback != NULL)
|
|
{
|
|
if (cbitem != NULL)
|
|
invoke_one_time_callback(channel, cbhead, cbitem, argv);
|
|
else
|
|
{
|
|
/* invoke the channel callback */
|
|
ch_logs(channel, "Invoking channel callback %s",
|
|
(char *)callback);
|
|
invoke_callback(channel, callback, partial, argv);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
ch_logn(channel, "Dropping message %d", seq_nr);
|
|
|
|
if (listtv != NULL)
|
|
free_tv(listtv);
|
|
vim_free(msg);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Return TRUE when channel "channel" is open for writing to.
|
|
* Also returns FALSE or invalid "channel".
|
|
*/
|
|
int
|
|
channel_can_write_to(channel_T *channel)
|
|
{
|
|
return channel != NULL && (channel->CH_SOCK_FD != INVALID_FD
|
|
|| channel->CH_IN_FD != INVALID_FD);
|
|
}
|
|
|
|
/*
|
|
* Return TRUE when channel "channel" is open for reading or writing.
|
|
* Also returns FALSE for invalid "channel".
|
|
*/
|
|
int
|
|
channel_is_open(channel_T *channel)
|
|
{
|
|
return channel != NULL && (channel->CH_SOCK_FD != INVALID_FD
|
|
|| channel->CH_IN_FD != INVALID_FD
|
|
|| channel->CH_OUT_FD != INVALID_FD
|
|
|| channel->CH_ERR_FD != INVALID_FD);
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if "channel" has JSON or other typeahead.
|
|
*/
|
|
int
|
|
channel_has_readahead(channel_T *channel, ch_part_T part)
|
|
{
|
|
ch_mode_T ch_mode = channel->ch_part[part].ch_mode;
|
|
|
|
if (ch_mode == MODE_JSON || ch_mode == MODE_JS)
|
|
{
|
|
jsonq_T *head = &channel->ch_part[part].ch_json_head;
|
|
jsonq_T *item = head->jq_next;
|
|
|
|
return item != NULL;
|
|
}
|
|
return channel_peek(channel, part) != NULL;
|
|
}
|
|
|
|
/*
|
|
* Return a string indicating the status of the channel.
|
|
* If "req_part" is not negative check that part.
|
|
*/
|
|
char *
|
|
channel_status(channel_T *channel, int req_part)
|
|
{
|
|
ch_part_T part;
|
|
int has_readahead = FALSE;
|
|
|
|
if (channel == NULL)
|
|
return "fail";
|
|
if (req_part == PART_OUT)
|
|
{
|
|
if (channel->CH_OUT_FD != INVALID_FD)
|
|
return "open";
|
|
if (channel_has_readahead(channel, PART_OUT))
|
|
has_readahead = TRUE;
|
|
}
|
|
else if (req_part == PART_ERR)
|
|
{
|
|
if (channel->CH_ERR_FD != INVALID_FD)
|
|
return "open";
|
|
if (channel_has_readahead(channel, PART_ERR))
|
|
has_readahead = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (channel_is_open(channel))
|
|
return "open";
|
|
for (part = PART_SOCK; part < PART_IN; ++part)
|
|
if (channel_has_readahead(channel, part))
|
|
{
|
|
has_readahead = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (has_readahead)
|
|
return "buffered";
|
|
return "closed";
|
|
}
|
|
|
|
static void
|
|
channel_part_info(channel_T *channel, dict_T *dict, char *name, ch_part_T part)
|
|
{
|
|
chanpart_T *chanpart = &channel->ch_part[part];
|
|
char namebuf[20]; /* longest is "sock_timeout" */
|
|
size_t tail;
|
|
char *status;
|
|
char *s = "";
|
|
|
|
vim_strncpy((char_u *)namebuf, (char_u *)name, 4);
|
|
STRCAT(namebuf, "_");
|
|
tail = STRLEN(namebuf);
|
|
|
|
STRCPY(namebuf + tail, "status");
|
|
if (chanpart->ch_fd != INVALID_FD)
|
|
status = "open";
|
|
else if (channel_has_readahead(channel, part))
|
|
status = "buffered";
|
|
else
|
|
status = "closed";
|
|
dict_add_nr_str(dict, namebuf, 0, (char_u *)status);
|
|
|
|
STRCPY(namebuf + tail, "mode");
|
|
switch (chanpart->ch_mode)
|
|
{
|
|
case MODE_NL: s = "NL"; break;
|
|
case MODE_RAW: s = "RAW"; break;
|
|
case MODE_JSON: s = "JSON"; break;
|
|
case MODE_JS: s = "JS"; break;
|
|
}
|
|
dict_add_nr_str(dict, namebuf, 0, (char_u *)s);
|
|
|
|
STRCPY(namebuf + tail, "io");
|
|
if (part == PART_SOCK)
|
|
s = "socket";
|
|
else switch (chanpart->ch_io)
|
|
{
|
|
case JIO_NULL: s = "null"; break;
|
|
case JIO_PIPE: s = "pipe"; break;
|
|
case JIO_FILE: s = "file"; break;
|
|
case JIO_BUFFER: s = "buffer"; break;
|
|
case JIO_OUT: s = "out"; break;
|
|
}
|
|
dict_add_nr_str(dict, namebuf, 0, (char_u *)s);
|
|
|
|
STRCPY(namebuf + tail, "timeout");
|
|
dict_add_nr_str(dict, namebuf, chanpart->ch_timeout, NULL);
|
|
}
|
|
|
|
void
|
|
channel_info(channel_T *channel, dict_T *dict)
|
|
{
|
|
dict_add_nr_str(dict, "id", channel->ch_id, NULL);
|
|
dict_add_nr_str(dict, "status", 0, (char_u *)channel_status(channel, -1));
|
|
|
|
if (channel->ch_hostname != NULL)
|
|
{
|
|
dict_add_nr_str(dict, "hostname", 0, (char_u *)channel->ch_hostname);
|
|
dict_add_nr_str(dict, "port", channel->ch_port, NULL);
|
|
channel_part_info(channel, dict, "sock", PART_SOCK);
|
|
}
|
|
else
|
|
{
|
|
channel_part_info(channel, dict, "out", PART_OUT);
|
|
channel_part_info(channel, dict, "err", PART_ERR);
|
|
channel_part_info(channel, dict, "in", PART_IN);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Close channel "channel".
|
|
* Trigger the close callback if "invoke_close_cb" is TRUE.
|
|
* Does not clear the buffers.
|
|
*/
|
|
void
|
|
channel_close(channel_T *channel, int invoke_close_cb)
|
|
{
|
|
ch_log(channel, "Closing channel");
|
|
|
|
#ifdef FEAT_GUI
|
|
channel_gui_unregister(channel);
|
|
#endif
|
|
|
|
ch_close_part(channel, PART_SOCK);
|
|
ch_close_part(channel, PART_IN);
|
|
ch_close_part(channel, PART_OUT);
|
|
ch_close_part(channel, PART_ERR);
|
|
|
|
if (invoke_close_cb && channel->ch_close_cb != NULL)
|
|
{
|
|
typval_T argv[1];
|
|
typval_T rettv;
|
|
int dummy;
|
|
ch_part_T part;
|
|
|
|
/* Invoke callbacks before the close callback, since it's weird to
|
|
* first invoke the close callback. Increment the refcount to avoid
|
|
* the channel being freed halfway. */
|
|
++channel->ch_refcount;
|
|
ch_log(channel, "Invoking callbacks before closing");
|
|
for (part = PART_SOCK; part < PART_IN; ++part)
|
|
while (may_invoke_callback(channel, part))
|
|
;
|
|
|
|
/* Invoke the close callback, if still set. */
|
|
if (channel->ch_close_cb != NULL)
|
|
{
|
|
ch_logs(channel, "Invoking close callback %s",
|
|
(char *)channel->ch_close_cb);
|
|
argv[0].v_type = VAR_CHANNEL;
|
|
argv[0].vval.v_channel = channel;
|
|
call_func(channel->ch_close_cb, (int)STRLEN(channel->ch_close_cb),
|
|
&rettv, 1, argv, NULL, 0L, 0L, &dummy, TRUE,
|
|
channel->ch_close_partial, NULL);
|
|
clear_tv(&rettv);
|
|
channel_need_redraw = TRUE;
|
|
}
|
|
|
|
/* the callback is only called once */
|
|
free_callback(channel->ch_close_cb, channel->ch_close_partial);
|
|
channel->ch_close_cb = NULL;
|
|
channel->ch_close_partial = NULL;
|
|
|
|
--channel->ch_refcount;
|
|
|
|
if (channel_need_redraw)
|
|
{
|
|
channel_need_redraw = FALSE;
|
|
redraw_after_callback();
|
|
}
|
|
|
|
if (!channel->ch_drop_never)
|
|
/* any remaining messages are useless now */
|
|
for (part = PART_SOCK; part < PART_IN; ++part)
|
|
drop_messages(channel, part);
|
|
}
|
|
|
|
channel->ch_nb_close_cb = NULL;
|
|
}
|
|
|
|
/*
|
|
* Close the "in" part channel "channel".
|
|
*/
|
|
void
|
|
channel_close_in(channel_T *channel)
|
|
{
|
|
ch_close_part(channel, PART_IN);
|
|
}
|
|
|
|
/*
|
|
* Clear the read buffer on "channel"/"part".
|
|
*/
|
|
static void
|
|
channel_clear_one(channel_T *channel, ch_part_T part)
|
|
{
|
|
jsonq_T *json_head = &channel->ch_part[part].ch_json_head;
|
|
cbq_T *cb_head = &channel->ch_part[part].ch_cb_head;
|
|
|
|
while (channel_peek(channel, part) != NULL)
|
|
vim_free(channel_get(channel, part));
|
|
|
|
while (cb_head->cq_next != NULL)
|
|
{
|
|
cbq_T *node = cb_head->cq_next;
|
|
|
|
remove_cb_node(cb_head, node);
|
|
free_callback(node->cq_callback, node->cq_partial);
|
|
vim_free(node);
|
|
}
|
|
|
|
while (json_head->jq_next != NULL)
|
|
{
|
|
free_tv(json_head->jq_next->jq_value);
|
|
remove_json_node(json_head, json_head->jq_next);
|
|
}
|
|
|
|
free_callback(channel->ch_part[part].ch_callback,
|
|
channel->ch_part[part].ch_partial);
|
|
channel->ch_part[part].ch_callback = NULL;
|
|
channel->ch_part[part].ch_partial = NULL;
|
|
}
|
|
|
|
/*
|
|
* Clear all the read buffers on "channel".
|
|
*/
|
|
void
|
|
channel_clear(channel_T *channel)
|
|
{
|
|
ch_log(channel, "Clearing channel");
|
|
vim_free(channel->ch_hostname);
|
|
channel->ch_hostname = NULL;
|
|
channel_clear_one(channel, PART_SOCK);
|
|
channel_clear_one(channel, PART_OUT);
|
|
channel_clear_one(channel, PART_ERR);
|
|
/* there is no callback or queue for PART_IN */
|
|
free_callback(channel->ch_callback, channel->ch_partial);
|
|
channel->ch_callback = NULL;
|
|
channel->ch_partial = NULL;
|
|
free_callback(channel->ch_close_cb, channel->ch_close_partial);
|
|
channel->ch_close_cb = NULL;
|
|
channel->ch_close_partial = NULL;
|
|
}
|
|
|
|
#if defined(EXITFREE) || defined(PROTO)
|
|
void
|
|
channel_free_all(void)
|
|
{
|
|
channel_T *channel;
|
|
|
|
ch_log(NULL, "channel_free_all()");
|
|
for (channel = first_channel; channel != NULL; channel = channel->ch_next)
|
|
channel_clear(channel);
|
|
}
|
|
#endif
|
|
|
|
|
|
/* Sent when the netbeans channel is found closed when reading. */
|
|
#define DETACH_MSG_RAW "DETACH\n"
|
|
|
|
/* Buffer size for reading incoming messages. */
|
|
#define MAXMSGSIZE 4096
|
|
|
|
#if defined(HAVE_SELECT)
|
|
/*
|
|
* Add write fds where we are waiting for writing to be possible.
|
|
*/
|
|
static int
|
|
channel_fill_wfds(int maxfd_arg, fd_set *wfds)
|
|
{
|
|
int maxfd = maxfd_arg;
|
|
channel_T *ch;
|
|
|
|
for (ch = first_channel; ch != NULL; ch = ch->ch_next)
|
|
{
|
|
chanpart_T *in_part = &ch->ch_part[PART_IN];
|
|
|
|
if (in_part->ch_fd != INVALID_FD && in_part->ch_bufref.br_buf != NULL)
|
|
{
|
|
FD_SET((int)in_part->ch_fd, wfds);
|
|
if ((int)in_part->ch_fd >= maxfd)
|
|
maxfd = (int)in_part->ch_fd + 1;
|
|
}
|
|
}
|
|
return maxfd;
|
|
}
|
|
#else
|
|
/*
|
|
* Add write fds where we are waiting for writing to be possible.
|
|
*/
|
|
static int
|
|
channel_fill_poll_write(int nfd_in, struct pollfd *fds)
|
|
{
|
|
int nfd = nfd_in;
|
|
channel_T *ch;
|
|
|
|
for (ch = first_channel; ch != NULL; ch = ch->ch_next)
|
|
{
|
|
chanpart_T *in_part = &ch->ch_part[PART_IN];
|
|
|
|
if (in_part->ch_fd != INVALID_FD && in_part->ch_bufref.br_buf != NULL)
|
|
{
|
|
in_part->ch_poll_idx = nfd;
|
|
fds[nfd].fd = in_part->ch_fd;
|
|
fds[nfd].events = POLLOUT;
|
|
++nfd;
|
|
}
|
|
else
|
|
in_part->ch_poll_idx = -1;
|
|
}
|
|
return nfd;
|
|
}
|
|
#endif
|
|
|
|
typedef enum {
|
|
CW_READY,
|
|
CW_NOT_READY,
|
|
CW_ERROR
|
|
} channel_wait_result;
|
|
|
|
/*
|
|
* Check for reading from "fd" with "timeout" msec.
|
|
* Return CW_READY when there is something to read.
|
|
* Return CW_NOT_READY when there is nothing to read.
|
|
* Return CW_ERROR when there is an error.
|
|
*/
|
|
static channel_wait_result
|
|
channel_wait(channel_T *channel, sock_T fd, int timeout)
|
|
{
|
|
if (timeout > 0)
|
|
ch_logn(channel, "Waiting for up to %d msec", timeout);
|
|
|
|
# ifdef WIN32
|
|
if (fd != channel->CH_SOCK_FD)
|
|
{
|
|
DWORD nread;
|
|
int sleep_time;
|
|
DWORD deadline = GetTickCount() + timeout;
|
|
int delay = 1;
|
|
|
|
/* reading from a pipe, not a socket */
|
|
while (TRUE)
|
|
{
|
|
int r = PeekNamedPipe((HANDLE)fd, NULL, 0, NULL, &nread, NULL);
|
|
|
|
if (r && nread > 0)
|
|
return CW_READY;
|
|
if (r == 0)
|
|
return CW_ERROR;
|
|
|
|
/* perhaps write some buffer lines */
|
|
channel_write_any_lines();
|
|
|
|
sleep_time = deadline - GetTickCount();
|
|
if (sleep_time <= 0)
|
|
break;
|
|
/* Wait for a little while. Very short at first, up to 10 msec
|
|
* after looping a few times. */
|
|
if (sleep_time > delay)
|
|
sleep_time = delay;
|
|
Sleep(sleep_time);
|
|
delay = delay * 2;
|
|
if (delay > 10)
|
|
delay = 10;
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
#if defined(HAVE_SELECT)
|
|
struct timeval tval;
|
|
fd_set rfds;
|
|
fd_set wfds;
|
|
int ret;
|
|
int maxfd;
|
|
|
|
tval.tv_sec = timeout / 1000;
|
|
tval.tv_usec = (timeout % 1000) * 1000;
|
|
for (;;)
|
|
{
|
|
FD_ZERO(&rfds);
|
|
FD_SET((int)fd, &rfds);
|
|
|
|
/* Write lines to a pipe when a pipe can be written to. Need to
|
|
* set this every time, some buffers may be done. */
|
|
maxfd = (int)fd + 1;
|
|
FD_ZERO(&wfds);
|
|
maxfd = channel_fill_wfds(maxfd, &wfds);
|
|
|
|
ret = select(maxfd, &rfds, &wfds, NULL, &tval);
|
|
# ifdef EINTR
|
|
SOCK_ERRNO;
|
|
if (ret == -1 && errno == EINTR)
|
|
continue;
|
|
# endif
|
|
if (ret > 0)
|
|
{
|
|
if (FD_ISSET(fd, &rfds))
|
|
return CW_READY;
|
|
channel_write_any_lines();
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
#else
|
|
for (;;)
|
|
{
|
|
struct pollfd fds[MAX_OPEN_CHANNELS + 1];
|
|
int nfd = 1;
|
|
|
|
fds[0].fd = fd;
|
|
fds[0].events = POLLIN;
|
|
nfd = channel_fill_poll_write(nfd, fds);
|
|
if (poll(fds, nfd, timeout) > 0)
|
|
{
|
|
if (fds[0].revents & POLLIN)
|
|
return CW_READY;
|
|
channel_write_any_lines();
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
return CW_NOT_READY;
|
|
}
|
|
|
|
static void
|
|
ch_close_part_on_error(
|
|
channel_T *channel, ch_part_T part, int is_err, char *func)
|
|
{
|
|
char msgbuf[80];
|
|
|
|
vim_snprintf(msgbuf, sizeof(msgbuf),
|
|
"%%s(): Read %s from ch_part[%d], closing",
|
|
(is_err ? "error" : "EOF"), part);
|
|
|
|
if (is_err)
|
|
/* Do not call emsg(), most likely the other end just exited. */
|
|
ch_errors(channel, msgbuf, func);
|
|
else
|
|
ch_logs(channel, msgbuf, func);
|
|
|
|
/* Queue a "DETACH" netbeans message in the command queue in order to
|
|
* terminate the netbeans session later. Do not end the session here
|
|
* directly as we may be running in the context of a call to
|
|
* netbeans_parse_messages():
|
|
* netbeans_parse_messages
|
|
* -> autocmd triggered while processing the netbeans cmd
|
|
* -> ui_breakcheck
|
|
* -> gui event loop or select loop
|
|
* -> channel_read()
|
|
* Only send "DETACH" for a netbeans channel.
|
|
*/
|
|
if (channel->ch_nb_close_cb != NULL)
|
|
channel_save(channel, PART_SOCK, (char_u *)DETACH_MSG_RAW,
|
|
(int)STRLEN(DETACH_MSG_RAW), FALSE, "PUT ");
|
|
|
|
/* When reading is not possible close this part of the channel. Don't
|
|
* close the channel yet, there may be something to read on another part. */
|
|
ch_close_part(channel, part);
|
|
|
|
#ifdef FEAT_GUI
|
|
/* Stop listening to GUI events right away. */
|
|
channel_gui_unregister_one(channel, part);
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
channel_close_now(channel_T *channel)
|
|
{
|
|
ch_log(channel, "Closing channel because all readable fds are closed");
|
|
if (channel->ch_nb_close_cb != NULL)
|
|
(*channel->ch_nb_close_cb)();
|
|
channel_close(channel, TRUE);
|
|
}
|
|
|
|
/*
|
|
* Read from channel "channel" for as long as there is something to read.
|
|
* "part" is PART_SOCK, PART_OUT or PART_ERR.
|
|
* The data is put in the read queue. No callbacks are invoked here.
|
|
*/
|
|
static void
|
|
channel_read(channel_T *channel, ch_part_T part, char *func)
|
|
{
|
|
static char_u *buf = NULL;
|
|
int len = 0;
|
|
int readlen = 0;
|
|
sock_T fd;
|
|
int use_socket = FALSE;
|
|
|
|
fd = channel->ch_part[part].ch_fd;
|
|
if (fd == INVALID_FD)
|
|
{
|
|
ch_errors(channel, "channel_read() called while %s part is closed",
|
|
part_names[part]);
|
|
return;
|
|
}
|
|
use_socket = fd == channel->CH_SOCK_FD;
|
|
|
|
/* Allocate a buffer to read into. */
|
|
if (buf == NULL)
|
|
{
|
|
buf = alloc(MAXMSGSIZE);
|
|
if (buf == NULL)
|
|
return; /* out of memory! */
|
|
}
|
|
|
|
/* Keep on reading for as long as there is something to read.
|
|
* Use select() or poll() to avoid blocking on a message that is exactly
|
|
* MAXMSGSIZE long. */
|
|
for (;;)
|
|
{
|
|
if (channel_wait(channel, fd, 0) != CW_READY)
|
|
break;
|
|
if (use_socket)
|
|
len = sock_read(fd, (char *)buf, MAXMSGSIZE);
|
|
else
|
|
len = fd_read(fd, (char *)buf, MAXMSGSIZE);
|
|
if (len <= 0)
|
|
break; /* error or nothing more to read */
|
|
|
|
/* Store the read message in the queue. */
|
|
channel_save(channel, part, buf, len, FALSE, "RECV ");
|
|
readlen += len;
|
|
if (len < MAXMSGSIZE)
|
|
break; /* did read everything that's available */
|
|
}
|
|
|
|
/* Reading a disconnection (readlen == 0), or an error. */
|
|
if (readlen <= 0)
|
|
ch_close_part_on_error(channel, part, (len < 0), func);
|
|
|
|
#if defined(CH_HAS_GUI) && defined(FEAT_GUI_GTK)
|
|
/* signal the main loop that there is something to read */
|
|
if (CH_HAS_GUI && gtk_main_level() > 0)
|
|
gtk_main_quit();
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Read from RAW or NL "channel"/"part". Blocks until there is something to
|
|
* read or the timeout expires.
|
|
* Returns what was read in allocated memory.
|
|
* Returns NULL in case of error or timeout.
|
|
*/
|
|
char_u *
|
|
channel_read_block(channel_T *channel, ch_part_T part, int timeout)
|
|
{
|
|
char_u *buf;
|
|
char_u *msg;
|
|
ch_mode_T mode = channel->ch_part[part].ch_mode;
|
|
sock_T fd = channel->ch_part[part].ch_fd;
|
|
char_u *nl;
|
|
readq_T *node;
|
|
|
|
ch_logsn(channel, "Blocking %s read, timeout: %d msec",
|
|
mode == MODE_RAW ? "RAW" : "NL", timeout);
|
|
|
|
while (TRUE)
|
|
{
|
|
node = channel_peek(channel, part);
|
|
if (node != NULL)
|
|
{
|
|
if (mode == MODE_RAW || (mode == MODE_NL
|
|
&& channel_first_nl(node) != NULL))
|
|
/* got a complete message */
|
|
break;
|
|
if (channel_collapse(channel, part, mode == MODE_NL) == OK)
|
|
continue;
|
|
}
|
|
|
|
/* Wait for up to the channel timeout. */
|
|
if (fd == INVALID_FD)
|
|
return NULL;
|
|
if (channel_wait(channel, fd, timeout) != CW_READY)
|
|
{
|
|
ch_log(channel, "Timed out");
|
|
return NULL;
|
|
}
|
|
channel_read(channel, part, "channel_read_block");
|
|
}
|
|
|
|
/* We have a complete message now. */
|
|
if (mode == MODE_RAW)
|
|
{
|
|
msg = channel_get_all(channel, part);
|
|
}
|
|
else
|
|
{
|
|
char_u *p;
|
|
|
|
buf = node->rq_buffer;
|
|
nl = channel_first_nl(node);
|
|
|
|
/* Convert NUL to NL, the internal representation. */
|
|
for (p = buf; p < nl && p < buf + node->rq_buflen; ++p)
|
|
if (*p == NUL)
|
|
*p = NL;
|
|
|
|
if (nl + 1 == buf + node->rq_buflen)
|
|
{
|
|
/* get the whole buffer */
|
|
msg = channel_get(channel, part);
|
|
*nl = NUL;
|
|
}
|
|
else
|
|
{
|
|
/* Copy the message into allocated memory and remove it from the
|
|
* buffer. */
|
|
msg = vim_strnsave(buf, (int)(nl - buf));
|
|
channel_consume(channel, part, (int)(nl - buf) + 1);
|
|
}
|
|
}
|
|
if (log_fd != NULL)
|
|
ch_logn(channel, "Returning %d bytes", (int)STRLEN(msg));
|
|
return msg;
|
|
}
|
|
|
|
/*
|
|
* Read one JSON message with ID "id" from "channel"/"part" and store the
|
|
* result in "rettv".
|
|
* When "id" is -1 accept any message;
|
|
* Blocks until the message is received or the timeout is reached.
|
|
*/
|
|
static int
|
|
channel_read_json_block(
|
|
channel_T *channel,
|
|
ch_part_T part,
|
|
int timeout_arg,
|
|
int id,
|
|
typval_T **rettv)
|
|
{
|
|
int more;
|
|
sock_T fd;
|
|
int timeout;
|
|
chanpart_T *chanpart = &channel->ch_part[part];
|
|
|
|
ch_log(channel, "Reading JSON");
|
|
if (id != -1)
|
|
chanpart->ch_block_id = id;
|
|
for (;;)
|
|
{
|
|
more = channel_parse_json(channel, part);
|
|
|
|
/* search for message "id" */
|
|
if (channel_get_json(channel, part, id, TRUE, rettv) == OK)
|
|
{
|
|
chanpart->ch_block_id = 0;
|
|
return OK;
|
|
}
|
|
|
|
if (!more)
|
|
{
|
|
/* Handle any other messages in the queue. If done some more
|
|
* messages may have arrived. */
|
|
if (channel_parse_messages())
|
|
continue;
|
|
|
|
/* Wait for up to the timeout. If there was an incomplete message
|
|
* use the deadline for that. */
|
|
timeout = timeout_arg;
|
|
if (chanpart->ch_wait_len > 0)
|
|
{
|
|
#ifdef WIN32
|
|
timeout = chanpart->ch_deadline - GetTickCount() + 1;
|
|
#else
|
|
{
|
|
struct timeval now_tv;
|
|
|
|
gettimeofday(&now_tv, NULL);
|
|
timeout = (chanpart->ch_deadline.tv_sec
|
|
- now_tv.tv_sec) * 1000
|
|
+ (chanpart->ch_deadline.tv_usec
|
|
- now_tv.tv_usec) / 1000
|
|
+ 1;
|
|
}
|
|
#endif
|
|
if (timeout < 0)
|
|
{
|
|
/* Something went wrong, channel_parse_json() didn't
|
|
* discard message. Cancel waiting. */
|
|
chanpart->ch_wait_len = 0;
|
|
timeout = timeout_arg;
|
|
}
|
|
else if (timeout > timeout_arg)
|
|
timeout = timeout_arg;
|
|
}
|
|
fd = chanpart->ch_fd;
|
|
if (fd == INVALID_FD
|
|
|| channel_wait(channel, fd, timeout) != CW_READY)
|
|
{
|
|
if (timeout == timeout_arg)
|
|
{
|
|
if (fd != INVALID_FD)
|
|
ch_log(channel, "Timed out");
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
channel_read(channel, part, "channel_read_json_block");
|
|
}
|
|
}
|
|
chanpart->ch_block_id = 0;
|
|
return FAIL;
|
|
}
|
|
|
|
/*
|
|
* Common for ch_read() and ch_readraw().
|
|
*/
|
|
void
|
|
common_channel_read(typval_T *argvars, typval_T *rettv, int raw)
|
|
{
|
|
channel_T *channel;
|
|
ch_part_T part = PART_COUNT;
|
|
jobopt_T opt;
|
|
int mode;
|
|
int timeout;
|
|
int id = -1;
|
|
typval_T *listtv = NULL;
|
|
|
|
/* return an empty string by default */
|
|
rettv->v_type = VAR_STRING;
|
|
rettv->vval.v_string = NULL;
|
|
|
|
clear_job_options(&opt);
|
|
if (get_job_options(&argvars[1], &opt, JO_TIMEOUT + JO_PART + JO_ID)
|
|
== FAIL)
|
|
goto theend;
|
|
|
|
if (opt.jo_set & JO_PART)
|
|
part = opt.jo_part;
|
|
channel = get_channel_arg(&argvars[0], TRUE, TRUE, part);
|
|
if (channel != NULL)
|
|
{
|
|
if (part == PART_COUNT)
|
|
part = channel_part_read(channel);
|
|
mode = channel_get_mode(channel, part);
|
|
timeout = channel_get_timeout(channel, part);
|
|
if (opt.jo_set & JO_TIMEOUT)
|
|
timeout = opt.jo_timeout;
|
|
|
|
if (raw || mode == MODE_RAW || mode == MODE_NL)
|
|
rettv->vval.v_string = channel_read_block(channel, part, timeout);
|
|
else
|
|
{
|
|
if (opt.jo_set & JO_ID)
|
|
id = opt.jo_id;
|
|
channel_read_json_block(channel, part, timeout, id, &listtv);
|
|
if (listtv != NULL)
|
|
{
|
|
*rettv = *listtv;
|
|
vim_free(listtv);
|
|
}
|
|
else
|
|
{
|
|
rettv->v_type = VAR_SPECIAL;
|
|
rettv->vval.v_number = VVAL_NONE;
|
|
}
|
|
}
|
|
}
|
|
|
|
theend:
|
|
free_job_options(&opt);
|
|
}
|
|
|
|
# if defined(WIN32) || defined(FEAT_GUI_X11) || defined(FEAT_GUI_GTK) \
|
|
|| defined(PROTO)
|
|
/*
|
|
* Lookup the channel from the socket. Set "partp" to the fd index.
|
|
* Returns NULL when the socket isn't found.
|
|
*/
|
|
channel_T *
|
|
channel_fd2channel(sock_T fd, ch_part_T *partp)
|
|
{
|
|
channel_T *channel;
|
|
ch_part_T part;
|
|
|
|
if (fd != INVALID_FD)
|
|
for (channel = first_channel; channel != NULL;
|
|
channel = channel->ch_next)
|
|
{
|
|
for (part = PART_SOCK; part < PART_IN; ++part)
|
|
if (channel->ch_part[part].ch_fd == fd)
|
|
{
|
|
*partp = part;
|
|
return channel;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
# endif
|
|
|
|
# if defined(WIN32) || defined(PROTO)
|
|
/*
|
|
* Check the channels for anything that is ready to be read.
|
|
* The data is put in the read queue.
|
|
*/
|
|
void
|
|
channel_handle_events(void)
|
|
{
|
|
channel_T *channel;
|
|
ch_part_T part;
|
|
sock_T fd;
|
|
|
|
for (channel = first_channel; channel != NULL; channel = channel->ch_next)
|
|
{
|
|
/* check the socket and pipes */
|
|
for (part = PART_SOCK; part < PART_IN; ++part)
|
|
{
|
|
fd = channel->ch_part[part].ch_fd;
|
|
if (fd != INVALID_FD)
|
|
{
|
|
int r = channel_wait(channel, fd, 0);
|
|
|
|
if (r == CW_READY)
|
|
channel_read(channel, part, "channel_handle_events");
|
|
else if (r == CW_ERROR)
|
|
ch_close_part_on_error(channel, part, TRUE,
|
|
"channel_handle_events");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
# endif
|
|
|
|
/*
|
|
* Write "buf" (NUL terminated string) to "channel"/"part".
|
|
* When "fun" is not NULL an error message might be given.
|
|
* Return FAIL or OK.
|
|
*/
|
|
int
|
|
channel_send(
|
|
channel_T *channel,
|
|
ch_part_T part,
|
|
char_u *buf,
|
|
int len,
|
|
char *fun)
|
|
{
|
|
int res;
|
|
sock_T fd;
|
|
|
|
fd = channel->ch_part[part].ch_fd;
|
|
if (fd == INVALID_FD)
|
|
{
|
|
if (!channel->ch_error && fun != NULL)
|
|
{
|
|
ch_errors(channel, "%s(): write while not connected", fun);
|
|
EMSG2(_("E630: %s(): write while not connected"), fun);
|
|
}
|
|
channel->ch_error = TRUE;
|
|
return FAIL;
|
|
}
|
|
|
|
if (log_fd != NULL)
|
|
{
|
|
ch_log_lead("SEND ", channel);
|
|
fprintf(log_fd, "'");
|
|
ignored = (int)fwrite(buf, len, 1, log_fd);
|
|
fprintf(log_fd, "'\n");
|
|
fflush(log_fd);
|
|
did_log_msg = TRUE;
|
|
}
|
|
|
|
if (part == PART_SOCK)
|
|
res = sock_write(fd, (char *)buf, len);
|
|
else
|
|
res = fd_write(fd, (char *)buf, len);
|
|
if (res != len)
|
|
{
|
|
if (!channel->ch_error && fun != NULL)
|
|
{
|
|
ch_errors(channel, "%s(): write failed", fun);
|
|
EMSG2(_("E631: %s(): write failed"), fun);
|
|
}
|
|
channel->ch_error = TRUE;
|
|
return FAIL;
|
|
}
|
|
|
|
channel->ch_error = FALSE;
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* Common for "ch_sendexpr()" and "ch_sendraw()".
|
|
* Returns the channel if the caller should read the response.
|
|
* Sets "part_read" to the read fd.
|
|
* Otherwise returns NULL.
|
|
*/
|
|
static channel_T *
|
|
send_common(
|
|
typval_T *argvars,
|
|
char_u *text,
|
|
int id,
|
|
int eval,
|
|
jobopt_T *opt,
|
|
char *fun,
|
|
ch_part_T *part_read)
|
|
{
|
|
channel_T *channel;
|
|
ch_part_T part_send;
|
|
|
|
clear_job_options(opt);
|
|
channel = get_channel_arg(&argvars[0], TRUE, FALSE, 0);
|
|
if (channel == NULL)
|
|
return NULL;
|
|
part_send = channel_part_send(channel);
|
|
*part_read = channel_part_read(channel);
|
|
|
|
if (get_job_options(&argvars[2], opt, JO_CALLBACK + JO_TIMEOUT) == FAIL)
|
|
return NULL;
|
|
|
|
/* Set the callback. An empty callback means no callback and not reading
|
|
* the response. With "ch_evalexpr()" and "ch_evalraw()" a callback is not
|
|
* allowed. */
|
|
if (opt->jo_callback != NULL && *opt->jo_callback != NUL)
|
|
{
|
|
if (eval)
|
|
{
|
|
EMSG2(_("E917: Cannot use a callback with %s()"), fun);
|
|
return NULL;
|
|
}
|
|
channel_set_req_callback(channel, *part_read,
|
|
opt->jo_callback, opt->jo_partial, id);
|
|
}
|
|
|
|
if (channel_send(channel, part_send, text, (int)STRLEN(text), fun) == OK
|
|
&& opt->jo_callback == NULL)
|
|
return channel;
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* common for "ch_evalexpr()" and "ch_sendexpr()"
|
|
*/
|
|
void
|
|
ch_expr_common(typval_T *argvars, typval_T *rettv, int eval)
|
|
{
|
|
char_u *text;
|
|
typval_T *listtv;
|
|
channel_T *channel;
|
|
int id;
|
|
ch_mode_T ch_mode;
|
|
ch_part_T part_send;
|
|
ch_part_T part_read;
|
|
jobopt_T opt;
|
|
int timeout;
|
|
|
|
/* return an empty string by default */
|
|
rettv->v_type = VAR_STRING;
|
|
rettv->vval.v_string = NULL;
|
|
|
|
channel = get_channel_arg(&argvars[0], TRUE, FALSE, 0);
|
|
if (channel == NULL)
|
|
return;
|
|
part_send = channel_part_send(channel);
|
|
|
|
ch_mode = channel_get_mode(channel, part_send);
|
|
if (ch_mode == MODE_RAW || ch_mode == MODE_NL)
|
|
{
|
|
EMSG(_("E912: cannot use ch_evalexpr()/ch_sendexpr() with a raw or nl channel"));
|
|
return;
|
|
}
|
|
|
|
id = ++channel->ch_last_msg_id;
|
|
text = json_encode_nr_expr(id, &argvars[1],
|
|
(ch_mode == MODE_JS ? JSON_JS : 0) | JSON_NL);
|
|
if (text == NULL)
|
|
return;
|
|
|
|
channel = send_common(argvars, text, id, eval, &opt,
|
|
eval ? "ch_evalexpr" : "ch_sendexpr", &part_read);
|
|
vim_free(text);
|
|
if (channel != NULL && eval)
|
|
{
|
|
if (opt.jo_set & JO_TIMEOUT)
|
|
timeout = opt.jo_timeout;
|
|
else
|
|
timeout = channel_get_timeout(channel, part_read);
|
|
if (channel_read_json_block(channel, part_read, timeout, id, &listtv)
|
|
== OK)
|
|
{
|
|
list_T *list = listtv->vval.v_list;
|
|
|
|
/* Move the item from the list and then change the type to
|
|
* avoid the value being freed. */
|
|
*rettv = list->lv_last->li_tv;
|
|
list->lv_last->li_tv.v_type = VAR_NUMBER;
|
|
free_tv(listtv);
|
|
}
|
|
}
|
|
free_job_options(&opt);
|
|
}
|
|
|
|
/*
|
|
* common for "ch_evalraw()" and "ch_sendraw()"
|
|
*/
|
|
void
|
|
ch_raw_common(typval_T *argvars, typval_T *rettv, int eval)
|
|
{
|
|
char_u buf[NUMBUFLEN];
|
|
char_u *text;
|
|
channel_T *channel;
|
|
ch_part_T part_read;
|
|
jobopt_T opt;
|
|
int timeout;
|
|
|
|
/* return an empty string by default */
|
|
rettv->v_type = VAR_STRING;
|
|
rettv->vval.v_string = NULL;
|
|
|
|
text = get_tv_string_buf(&argvars[1], buf);
|
|
channel = send_common(argvars, text, 0, eval, &opt,
|
|
eval ? "ch_evalraw" : "ch_sendraw", &part_read);
|
|
if (channel != NULL && eval)
|
|
{
|
|
if (opt.jo_set & JO_TIMEOUT)
|
|
timeout = opt.jo_timeout;
|
|
else
|
|
timeout = channel_get_timeout(channel, part_read);
|
|
rettv->vval.v_string = channel_read_block(channel, part_read, timeout);
|
|
}
|
|
free_job_options(&opt);
|
|
}
|
|
|
|
# if (defined(UNIX) && !defined(HAVE_SELECT)) || defined(PROTO)
|
|
/*
|
|
* Add open channels to the poll struct.
|
|
* Return the adjusted struct index.
|
|
* The type of "fds" is hidden to avoid problems with the function proto.
|
|
*/
|
|
int
|
|
channel_poll_setup(int nfd_in, void *fds_in)
|
|
{
|
|
int nfd = nfd_in;
|
|
channel_T *channel;
|
|
struct pollfd *fds = fds_in;
|
|
ch_part_T part;
|
|
|
|
for (channel = first_channel; channel != NULL; channel = channel->ch_next)
|
|
{
|
|
for (part = PART_SOCK; part < PART_IN; ++part)
|
|
{
|
|
chanpart_T *ch_part = &channel->ch_part[part];
|
|
|
|
if (ch_part->ch_fd != INVALID_FD)
|
|
{
|
|
ch_part->ch_poll_idx = nfd;
|
|
fds[nfd].fd = ch_part->ch_fd;
|
|
fds[nfd].events = POLLIN;
|
|
nfd++;
|
|
}
|
|
else
|
|
channel->ch_part[part].ch_poll_idx = -1;
|
|
}
|
|
}
|
|
|
|
nfd = channel_fill_poll_write(nfd, fds);
|
|
|
|
return nfd;
|
|
}
|
|
|
|
/*
|
|
* The type of "fds" is hidden to avoid problems with the function proto.
|
|
*/
|
|
int
|
|
channel_poll_check(int ret_in, void *fds_in)
|
|
{
|
|
int ret = ret_in;
|
|
channel_T *channel;
|
|
struct pollfd *fds = fds_in;
|
|
ch_part_T part;
|
|
int idx;
|
|
chanpart_T *in_part;
|
|
|
|
for (channel = first_channel; channel != NULL; channel = channel->ch_next)
|
|
{
|
|
for (part = PART_SOCK; part < PART_IN; ++part)
|
|
{
|
|
idx = channel->ch_part[part].ch_poll_idx;
|
|
|
|
if (ret > 0 && idx != -1 && (fds[idx].revents & POLLIN))
|
|
{
|
|
channel_read(channel, part, "channel_poll_check");
|
|
--ret;
|
|
}
|
|
}
|
|
|
|
in_part = &channel->ch_part[PART_IN];
|
|
idx = in_part->ch_poll_idx;
|
|
if (ret > 0 && idx != -1 && (fds[idx].revents & POLLOUT))
|
|
{
|
|
if (in_part->ch_buf_append)
|
|
{
|
|
if (in_part->ch_bufref.br_buf != NULL)
|
|
channel_write_new_lines(in_part->ch_bufref.br_buf);
|
|
}
|
|
else
|
|
channel_write_in(channel);
|
|
--ret;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
# endif /* UNIX && !HAVE_SELECT */
|
|
|
|
# if (!defined(WIN32) && defined(HAVE_SELECT)) || defined(PROTO)
|
|
/*
|
|
* The "fd_set" type is hidden to avoid problems with the function proto.
|
|
*/
|
|
int
|
|
channel_select_setup(int maxfd_in, void *rfds_in, void *wfds_in)
|
|
{
|
|
int maxfd = maxfd_in;
|
|
channel_T *channel;
|
|
fd_set *rfds = rfds_in;
|
|
fd_set *wfds = wfds_in;
|
|
ch_part_T part;
|
|
|
|
for (channel = first_channel; channel != NULL; channel = channel->ch_next)
|
|
{
|
|
for (part = PART_SOCK; part < PART_IN; ++part)
|
|
{
|
|
sock_T fd = channel->ch_part[part].ch_fd;
|
|
|
|
if (fd != INVALID_FD)
|
|
{
|
|
FD_SET((int)fd, rfds);
|
|
if (maxfd < (int)fd)
|
|
maxfd = (int)fd;
|
|
}
|
|
}
|
|
}
|
|
|
|
maxfd = channel_fill_wfds(maxfd, wfds);
|
|
|
|
return maxfd;
|
|
}
|
|
|
|
/*
|
|
* The "fd_set" type is hidden to avoid problems with the function proto.
|
|
*/
|
|
int
|
|
channel_select_check(int ret_in, void *rfds_in, void *wfds_in)
|
|
{
|
|
int ret = ret_in;
|
|
channel_T *channel;
|
|
fd_set *rfds = rfds_in;
|
|
fd_set *wfds = wfds_in;
|
|
ch_part_T part;
|
|
chanpart_T *in_part;
|
|
|
|
for (channel = first_channel; channel != NULL; channel = channel->ch_next)
|
|
{
|
|
for (part = PART_SOCK; part < PART_IN; ++part)
|
|
{
|
|
sock_T fd = channel->ch_part[part].ch_fd;
|
|
|
|
if (ret > 0 && fd != INVALID_FD && FD_ISSET(fd, rfds))
|
|
{
|
|
channel_read(channel, part, "channel_select_check");
|
|
--ret;
|
|
}
|
|
}
|
|
|
|
in_part = &channel->ch_part[PART_IN];
|
|
if (ret > 0 && in_part->ch_fd != INVALID_FD
|
|
&& FD_ISSET(in_part->ch_fd, wfds))
|
|
{
|
|
if (in_part->ch_buf_append)
|
|
{
|
|
if (in_part->ch_bufref.br_buf != NULL)
|
|
channel_write_new_lines(in_part->ch_bufref.br_buf);
|
|
}
|
|
else
|
|
channel_write_in(channel);
|
|
--ret;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
# endif /* !WIN32 && HAVE_SELECT */
|
|
|
|
/*
|
|
* Execute queued up commands.
|
|
* Invoked from the main loop when it's safe to execute received commands.
|
|
* Return TRUE when something was done.
|
|
*/
|
|
int
|
|
channel_parse_messages(void)
|
|
{
|
|
channel_T *channel = first_channel;
|
|
int ret = FALSE;
|
|
int r;
|
|
ch_part_T part = PART_SOCK;
|
|
#ifdef ELAPSED_FUNC
|
|
ELAPSED_TYPE start_tv;
|
|
|
|
ELAPSED_INIT(start_tv);
|
|
#endif
|
|
|
|
++safe_to_invoke_callback;
|
|
|
|
/* Only do this message when another message was given, otherwise we get
|
|
* lots of them. */
|
|
if (did_log_msg)
|
|
{
|
|
ch_log(NULL, "looking for messages on channels");
|
|
did_log_msg = FALSE;
|
|
}
|
|
while (channel != NULL)
|
|
{
|
|
if (channel->ch_to_be_closed == 0)
|
|
{
|
|
channel->ch_to_be_closed = (1 << PART_COUNT);
|
|
channel_close_now(channel);
|
|
/* channel may have been freed, start over */
|
|
channel = first_channel;
|
|
continue;
|
|
}
|
|
if (channel->ch_to_be_freed)
|
|
{
|
|
channel_free(channel);
|
|
/* channel has been freed, start over */
|
|
channel = first_channel;
|
|
continue;
|
|
}
|
|
if (channel->ch_refcount == 0 && !channel_still_useful(channel))
|
|
{
|
|
/* channel is no longer useful, free it */
|
|
channel_free(channel);
|
|
channel = first_channel;
|
|
part = PART_SOCK;
|
|
continue;
|
|
}
|
|
if (channel->ch_part[part].ch_fd != INVALID_FD
|
|
|| channel_has_readahead(channel, part))
|
|
{
|
|
/* Increase the refcount, in case the handler causes the channel
|
|
* to be unreferenced or closed. */
|
|
++channel->ch_refcount;
|
|
r = may_invoke_callback(channel, part);
|
|
if (r == OK)
|
|
ret = TRUE;
|
|
if (channel_unref(channel) || (r == OK
|
|
#ifdef ELAPSED_FUNC
|
|
/* Limit the time we loop here to 100 msec, otherwise
|
|
* Vim becomes unresponsive when the callback takes
|
|
* more than a bit of time. */
|
|
&& ELAPSED_FUNC(start_tv) < 100L
|
|
#endif
|
|
))
|
|
{
|
|
/* channel was freed or something was done, start over */
|
|
channel = first_channel;
|
|
part = PART_SOCK;
|
|
continue;
|
|
}
|
|
}
|
|
if (part < PART_ERR)
|
|
++part;
|
|
else
|
|
{
|
|
channel = channel->ch_next;
|
|
part = PART_SOCK;
|
|
}
|
|
}
|
|
|
|
if (channel_need_redraw)
|
|
{
|
|
channel_need_redraw = FALSE;
|
|
redraw_after_callback();
|
|
}
|
|
|
|
--safe_to_invoke_callback;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if any channel has readahead. That means we should not block on
|
|
* waiting for input.
|
|
*/
|
|
int
|
|
channel_any_readahead(void)
|
|
{
|
|
channel_T *channel = first_channel;
|
|
ch_part_T part = PART_SOCK;
|
|
|
|
while (channel != NULL)
|
|
{
|
|
if (channel_has_readahead(channel, part))
|
|
return TRUE;
|
|
if (part < PART_ERR)
|
|
++part;
|
|
else
|
|
{
|
|
channel = channel->ch_next;
|
|
part = PART_SOCK;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Mark references to lists used in channels.
|
|
*/
|
|
int
|
|
set_ref_in_channel(int copyID)
|
|
{
|
|
int abort = FALSE;
|
|
channel_T *channel;
|
|
typval_T tv;
|
|
|
|
for (channel = first_channel; channel != NULL; channel = channel->ch_next)
|
|
if (channel_still_useful(channel))
|
|
{
|
|
tv.v_type = VAR_CHANNEL;
|
|
tv.vval.v_channel = channel;
|
|
abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL);
|
|
}
|
|
return abort;
|
|
}
|
|
|
|
/*
|
|
* Return the "part" to write to for "channel".
|
|
*/
|
|
ch_part_T
|
|
channel_part_send(channel_T *channel)
|
|
{
|
|
if (channel->CH_SOCK_FD == INVALID_FD)
|
|
return PART_IN;
|
|
return PART_SOCK;
|
|
}
|
|
|
|
/*
|
|
* Return the default "part" to read from for "channel".
|
|
*/
|
|
ch_part_T
|
|
channel_part_read(channel_T *channel)
|
|
{
|
|
if (channel->CH_SOCK_FD == INVALID_FD)
|
|
return PART_OUT;
|
|
return PART_SOCK;
|
|
}
|
|
|
|
/*
|
|
* Return the mode of "channel"/"part"
|
|
* If "channel" is invalid returns MODE_JSON.
|
|
*/
|
|
ch_mode_T
|
|
channel_get_mode(channel_T *channel, ch_part_T part)
|
|
{
|
|
if (channel == NULL)
|
|
return MODE_JSON;
|
|
return channel->ch_part[part].ch_mode;
|
|
}
|
|
|
|
/*
|
|
* Return the timeout of "channel"/"part"
|
|
*/
|
|
int
|
|
channel_get_timeout(channel_T *channel, ch_part_T part)
|
|
{
|
|
return channel->ch_part[part].ch_timeout;
|
|
}
|
|
|
|
static int
|
|
handle_mode(typval_T *item, jobopt_T *opt, ch_mode_T *modep, int jo)
|
|
{
|
|
char_u *val = get_tv_string(item);
|
|
|
|
opt->jo_set |= jo;
|
|
if (STRCMP(val, "nl") == 0)
|
|
*modep = MODE_NL;
|
|
else if (STRCMP(val, "raw") == 0)
|
|
*modep = MODE_RAW;
|
|
else if (STRCMP(val, "js") == 0)
|
|
*modep = MODE_JS;
|
|
else if (STRCMP(val, "json") == 0)
|
|
*modep = MODE_JSON;
|
|
else
|
|
{
|
|
EMSG2(_(e_invarg2), val);
|
|
return FAIL;
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
static int
|
|
handle_io(typval_T *item, ch_part_T part, jobopt_T *opt)
|
|
{
|
|
char_u *val = get_tv_string(item);
|
|
|
|
opt->jo_set |= JO_OUT_IO << (part - PART_OUT);
|
|
if (STRCMP(val, "null") == 0)
|
|
opt->jo_io[part] = JIO_NULL;
|
|
else if (STRCMP(val, "pipe") == 0)
|
|
opt->jo_io[part] = JIO_PIPE;
|
|
else if (STRCMP(val, "file") == 0)
|
|
opt->jo_io[part] = JIO_FILE;
|
|
else if (STRCMP(val, "buffer") == 0)
|
|
opt->jo_io[part] = JIO_BUFFER;
|
|
else if (STRCMP(val, "out") == 0 && part == PART_ERR)
|
|
opt->jo_io[part] = JIO_OUT;
|
|
else
|
|
{
|
|
EMSG2(_(e_invarg2), val);
|
|
return FAIL;
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* Clear a jobopt_T before using it.
|
|
*/
|
|
void
|
|
clear_job_options(jobopt_T *opt)
|
|
{
|
|
vim_memset(opt, 0, sizeof(jobopt_T));
|
|
}
|
|
|
|
/*
|
|
* Free any members of a jobopt_T.
|
|
*/
|
|
void
|
|
free_job_options(jobopt_T *opt)
|
|
{
|
|
if (opt->jo_partial != NULL)
|
|
partial_unref(opt->jo_partial);
|
|
else if (opt->jo_callback != NULL)
|
|
func_unref(opt->jo_callback);
|
|
if (opt->jo_out_partial != NULL)
|
|
partial_unref(opt->jo_out_partial);
|
|
else if (opt->jo_out_cb != NULL)
|
|
func_unref(opt->jo_out_cb);
|
|
if (opt->jo_err_partial != NULL)
|
|
partial_unref(opt->jo_err_partial);
|
|
else if (opt->jo_err_cb != NULL)
|
|
func_unref(opt->jo_err_cb);
|
|
if (opt->jo_close_partial != NULL)
|
|
partial_unref(opt->jo_close_partial);
|
|
else if (opt->jo_close_cb != NULL)
|
|
func_unref(opt->jo_close_cb);
|
|
if (opt->jo_exit_partial != NULL)
|
|
partial_unref(opt->jo_exit_partial);
|
|
else if (opt->jo_exit_cb != NULL)
|
|
func_unref(opt->jo_exit_cb);
|
|
}
|
|
|
|
/*
|
|
* Get the PART_ number from the first character of an option name.
|
|
*/
|
|
static int
|
|
part_from_char(int c)
|
|
{
|
|
return c == 'i' ? PART_IN : c == 'o' ? PART_OUT: PART_ERR;
|
|
}
|
|
|
|
/*
|
|
* Get the option entries from the dict in "tv", parse them and put the result
|
|
* in "opt".
|
|
* Only accept options in "supported".
|
|
* If an option value is invalid return FAIL.
|
|
*/
|
|
int
|
|
get_job_options(typval_T *tv, jobopt_T *opt, int supported)
|
|
{
|
|
typval_T *item;
|
|
char_u *val;
|
|
dict_T *dict;
|
|
int todo;
|
|
hashitem_T *hi;
|
|
ch_part_T part;
|
|
|
|
opt->jo_set = 0;
|
|
if (tv->v_type == VAR_UNKNOWN)
|
|
return OK;
|
|
if (tv->v_type != VAR_DICT)
|
|
{
|
|
EMSG(_(e_invarg));
|
|
return FAIL;
|
|
}
|
|
dict = tv->vval.v_dict;
|
|
if (dict == NULL)
|
|
return OK;
|
|
|
|
todo = (int)dict->dv_hashtab.ht_used;
|
|
for (hi = dict->dv_hashtab.ht_array; todo > 0; ++hi)
|
|
if (!HASHITEM_EMPTY(hi))
|
|
{
|
|
item = &dict_lookup(hi)->di_tv;
|
|
|
|
if (STRCMP(hi->hi_key, "mode") == 0)
|
|
{
|
|
if (!(supported & JO_MODE))
|
|
break;
|
|
if (handle_mode(item, opt, &opt->jo_mode, JO_MODE) == FAIL)
|
|
return FAIL;
|
|
}
|
|
else if (STRCMP(hi->hi_key, "in_mode") == 0)
|
|
{
|
|
if (!(supported & JO_IN_MODE))
|
|
break;
|
|
if (handle_mode(item, opt, &opt->jo_in_mode, JO_IN_MODE)
|
|
== FAIL)
|
|
return FAIL;
|
|
}
|
|
else if (STRCMP(hi->hi_key, "out_mode") == 0)
|
|
{
|
|
if (!(supported & JO_OUT_MODE))
|
|
break;
|
|
if (handle_mode(item, opt, &opt->jo_out_mode, JO_OUT_MODE)
|
|
== FAIL)
|
|
return FAIL;
|
|
}
|
|
else if (STRCMP(hi->hi_key, "err_mode") == 0)
|
|
{
|
|
if (!(supported & JO_ERR_MODE))
|
|
break;
|
|
if (handle_mode(item, opt, &opt->jo_err_mode, JO_ERR_MODE)
|
|
== FAIL)
|
|
return FAIL;
|
|
}
|
|
else if (STRCMP(hi->hi_key, "in_io") == 0
|
|
|| STRCMP(hi->hi_key, "out_io") == 0
|
|
|| STRCMP(hi->hi_key, "err_io") == 0)
|
|
{
|
|
if (!(supported & JO_OUT_IO))
|
|
break;
|
|
if (handle_io(item, part_from_char(*hi->hi_key), opt) == FAIL)
|
|
return FAIL;
|
|
}
|
|
else if (STRCMP(hi->hi_key, "in_name") == 0
|
|
|| STRCMP(hi->hi_key, "out_name") == 0
|
|
|| STRCMP(hi->hi_key, "err_name") == 0)
|
|
{
|
|
part = part_from_char(*hi->hi_key);
|
|
|
|
if (!(supported & JO_OUT_IO))
|
|
break;
|
|
opt->jo_set |= JO_OUT_NAME << (part - PART_OUT);
|
|
opt->jo_io_name[part] =
|
|
get_tv_string_buf_chk(item, opt->jo_io_name_buf[part]);
|
|
}
|
|
else if (STRCMP(hi->hi_key, "in_buf") == 0
|
|
|| STRCMP(hi->hi_key, "out_buf") == 0
|
|
|| STRCMP(hi->hi_key, "err_buf") == 0)
|
|
{
|
|
part = part_from_char(*hi->hi_key);
|
|
|
|
if (!(supported & JO_OUT_IO))
|
|
break;
|
|
opt->jo_set |= JO_OUT_BUF << (part - PART_OUT);
|
|
opt->jo_io_buf[part] = get_tv_number(item);
|
|
if (opt->jo_io_buf[part] <= 0)
|
|
{
|
|
EMSG2(_(e_invarg2), get_tv_string(item));
|
|
return FAIL;
|
|
}
|
|
if (buflist_findnr(opt->jo_io_buf[part]) == NULL)
|
|
{
|
|
EMSGN(_(e_nobufnr), (long)opt->jo_io_buf[part]);
|
|
return FAIL;
|
|
}
|
|
}
|
|
else if (STRCMP(hi->hi_key, "out_modifiable") == 0
|
|
|| STRCMP(hi->hi_key, "err_modifiable") == 0)
|
|
{
|
|
part = part_from_char(*hi->hi_key);
|
|
|
|
if (!(supported & JO_OUT_IO))
|
|
break;
|
|
opt->jo_set |= JO_OUT_MODIFIABLE << (part - PART_OUT);
|
|
opt->jo_modifiable[part] = get_tv_number(item);
|
|
}
|
|
else if (STRCMP(hi->hi_key, "out_msg") == 0
|
|
|| STRCMP(hi->hi_key, "err_msg") == 0)
|
|
{
|
|
part = part_from_char(*hi->hi_key);
|
|
|
|
if (!(supported & JO_OUT_IO))
|
|
break;
|
|
opt->jo_set2 |= JO2_OUT_MSG << (part - PART_OUT);
|
|
opt->jo_message[part] = get_tv_number(item);
|
|
}
|
|
else if (STRCMP(hi->hi_key, "in_top") == 0
|
|
|| STRCMP(hi->hi_key, "in_bot") == 0)
|
|
{
|
|
linenr_T *lp;
|
|
|
|
if (!(supported & JO_OUT_IO))
|
|
break;
|
|
if (hi->hi_key[3] == 't')
|
|
{
|
|
lp = &opt->jo_in_top;
|
|
opt->jo_set |= JO_IN_TOP;
|
|
}
|
|
else
|
|
{
|
|
lp = &opt->jo_in_bot;
|
|
opt->jo_set |= JO_IN_BOT;
|
|
}
|
|
*lp = get_tv_number(item);
|
|
if (*lp < 0)
|
|
{
|
|
EMSG2(_(e_invarg2), get_tv_string(item));
|
|
return FAIL;
|
|
}
|
|
}
|
|
else if (STRCMP(hi->hi_key, "channel") == 0)
|
|
{
|
|
if (!(supported & JO_OUT_IO))
|
|
break;
|
|
opt->jo_set |= JO_CHANNEL;
|
|
if (item->v_type != VAR_CHANNEL)
|
|
{
|
|
EMSG2(_(e_invarg2), "channel");
|
|
return FAIL;
|
|
}
|
|
opt->jo_channel = item->vval.v_channel;
|
|
}
|
|
else if (STRCMP(hi->hi_key, "callback") == 0)
|
|
{
|
|
if (!(supported & JO_CALLBACK))
|
|
break;
|
|
opt->jo_set |= JO_CALLBACK;
|
|
opt->jo_callback = get_callback(item, &opt->jo_partial);
|
|
if (opt->jo_callback == NULL)
|
|
{
|
|
EMSG2(_(e_invarg2), "callback");
|
|
return FAIL;
|
|
}
|
|
}
|
|
else if (STRCMP(hi->hi_key, "out_cb") == 0)
|
|
{
|
|
if (!(supported & JO_OUT_CALLBACK))
|
|
break;
|
|
opt->jo_set |= JO_OUT_CALLBACK;
|
|
opt->jo_out_cb = get_callback(item, &opt->jo_out_partial);
|
|
if (opt->jo_out_cb == NULL)
|
|
{
|
|
EMSG2(_(e_invarg2), "out_cb");
|
|
return FAIL;
|
|
}
|
|
}
|
|
else if (STRCMP(hi->hi_key, "err_cb") == 0)
|
|
{
|
|
if (!(supported & JO_ERR_CALLBACK))
|
|
break;
|
|
opt->jo_set |= JO_ERR_CALLBACK;
|
|
opt->jo_err_cb = get_callback(item, &opt->jo_err_partial);
|
|
if (opt->jo_err_cb == NULL)
|
|
{
|
|
EMSG2(_(e_invarg2), "err_cb");
|
|
return FAIL;
|
|
}
|
|
}
|
|
else if (STRCMP(hi->hi_key, "close_cb") == 0)
|
|
{
|
|
if (!(supported & JO_CLOSE_CALLBACK))
|
|
break;
|
|
opt->jo_set |= JO_CLOSE_CALLBACK;
|
|
opt->jo_close_cb = get_callback(item, &opt->jo_close_partial);
|
|
if (opt->jo_close_cb == NULL)
|
|
{
|
|
EMSG2(_(e_invarg2), "close_cb");
|
|
return FAIL;
|
|
}
|
|
}
|
|
else if (STRCMP(hi->hi_key, "drop") == 0)
|
|
{
|
|
int never = FALSE;
|
|
val = get_tv_string(item);
|
|
|
|
if (STRCMP(val, "never") == 0)
|
|
never = TRUE;
|
|
else if (STRCMP(val, "auto") != 0)
|
|
{
|
|
EMSG2(_(e_invarg2), "drop");
|
|
return FAIL;
|
|
}
|
|
opt->jo_drop_never = never;
|
|
}
|
|
else if (STRCMP(hi->hi_key, "exit_cb") == 0)
|
|
{
|
|
if (!(supported & JO_EXIT_CB))
|
|
break;
|
|
opt->jo_set |= JO_EXIT_CB;
|
|
opt->jo_exit_cb = get_callback(item, &opt->jo_exit_partial);
|
|
if (opt->jo_exit_cb == NULL)
|
|
{
|
|
EMSG2(_(e_invarg2), "exit_cb");
|
|
return FAIL;
|
|
}
|
|
}
|
|
else if (STRCMP(hi->hi_key, "waittime") == 0)
|
|
{
|
|
if (!(supported & JO_WAITTIME))
|
|
break;
|
|
opt->jo_set |= JO_WAITTIME;
|
|
opt->jo_waittime = get_tv_number(item);
|
|
}
|
|
else if (STRCMP(hi->hi_key, "timeout") == 0)
|
|
{
|
|
if (!(supported & JO_TIMEOUT))
|
|
break;
|
|
opt->jo_set |= JO_TIMEOUT;
|
|
opt->jo_timeout = get_tv_number(item);
|
|
}
|
|
else if (STRCMP(hi->hi_key, "out_timeout") == 0)
|
|
{
|
|
if (!(supported & JO_OUT_TIMEOUT))
|
|
break;
|
|
opt->jo_set |= JO_OUT_TIMEOUT;
|
|
opt->jo_out_timeout = get_tv_number(item);
|
|
}
|
|
else if (STRCMP(hi->hi_key, "err_timeout") == 0)
|
|
{
|
|
if (!(supported & JO_ERR_TIMEOUT))
|
|
break;
|
|
opt->jo_set |= JO_ERR_TIMEOUT;
|
|
opt->jo_err_timeout = get_tv_number(item);
|
|
}
|
|
else if (STRCMP(hi->hi_key, "part") == 0)
|
|
{
|
|
if (!(supported & JO_PART))
|
|
break;
|
|
opt->jo_set |= JO_PART;
|
|
val = get_tv_string(item);
|
|
if (STRCMP(val, "err") == 0)
|
|
opt->jo_part = PART_ERR;
|
|
else if (STRCMP(val, "out") == 0)
|
|
opt->jo_part = PART_OUT;
|
|
else
|
|
{
|
|
EMSG2(_(e_invarg2), val);
|
|
return FAIL;
|
|
}
|
|
}
|
|
else if (STRCMP(hi->hi_key, "id") == 0)
|
|
{
|
|
if (!(supported & JO_ID))
|
|
break;
|
|
opt->jo_set |= JO_ID;
|
|
opt->jo_id = get_tv_number(item);
|
|
}
|
|
else if (STRCMP(hi->hi_key, "stoponexit") == 0)
|
|
{
|
|
if (!(supported & JO_STOPONEXIT))
|
|
break;
|
|
opt->jo_set |= JO_STOPONEXIT;
|
|
opt->jo_stoponexit = get_tv_string_buf_chk(item,
|
|
opt->jo_soe_buf);
|
|
if (opt->jo_stoponexit == NULL)
|
|
{
|
|
EMSG2(_(e_invarg2), "stoponexit");
|
|
return FAIL;
|
|
}
|
|
}
|
|
else if (STRCMP(hi->hi_key, "block_write") == 0)
|
|
{
|
|
if (!(supported & JO_BLOCK_WRITE))
|
|
break;
|
|
opt->jo_set |= JO_BLOCK_WRITE;
|
|
opt->jo_block_write = get_tv_number(item);
|
|
}
|
|
else
|
|
break;
|
|
--todo;
|
|
}
|
|
if (todo > 0)
|
|
{
|
|
EMSG2(_(e_invarg2), hi->hi_key);
|
|
return FAIL;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* Get the channel from the argument.
|
|
* Returns NULL if the handle is invalid.
|
|
* When "check_open" is TRUE check that the channel can be used.
|
|
* When "reading" is TRUE "check_open" considers typeahead useful.
|
|
* "part" is used to check typeahead, when PART_COUNT use the default part.
|
|
*/
|
|
channel_T *
|
|
get_channel_arg(typval_T *tv, int check_open, int reading, ch_part_T part)
|
|
{
|
|
channel_T *channel = NULL;
|
|
int has_readahead = FALSE;
|
|
|
|
if (tv->v_type == VAR_JOB)
|
|
{
|
|
if (tv->vval.v_job != NULL)
|
|
channel = tv->vval.v_job->jv_channel;
|
|
}
|
|
else if (tv->v_type == VAR_CHANNEL)
|
|
{
|
|
channel = tv->vval.v_channel;
|
|
}
|
|
else
|
|
{
|
|
EMSG2(_(e_invarg2), get_tv_string(tv));
|
|
return NULL;
|
|
}
|
|
if (channel != NULL && reading)
|
|
has_readahead = channel_has_readahead(channel,
|
|
part != PART_COUNT ? part : channel_part_read(channel));
|
|
|
|
if (check_open && (channel == NULL || (!channel_is_open(channel)
|
|
&& !(reading && has_readahead))))
|
|
{
|
|
EMSG(_("E906: not an open channel"));
|
|
return NULL;
|
|
}
|
|
return channel;
|
|
}
|
|
|
|
static job_T *first_job = NULL;
|
|
|
|
static void
|
|
job_free_contents(job_T *job)
|
|
{
|
|
ch_log(job->jv_channel, "Freeing job");
|
|
if (job->jv_channel != NULL)
|
|
{
|
|
/* The link from the channel to the job doesn't count as a reference,
|
|
* thus don't decrement the refcount of the job. The reference from
|
|
* the job to the channel does count the reference, decrement it and
|
|
* NULL the reference. We don't set ch_job_killed, unreferencing the
|
|
* job doesn't mean it stops running. */
|
|
job->jv_channel->ch_job = NULL;
|
|
channel_unref(job->jv_channel);
|
|
}
|
|
mch_clear_job(job);
|
|
|
|
vim_free(job->jv_stoponexit);
|
|
free_callback(job->jv_exit_cb, job->jv_exit_partial);
|
|
}
|
|
|
|
static void
|
|
job_free_job(job_T *job)
|
|
{
|
|
if (job->jv_next != NULL)
|
|
job->jv_next->jv_prev = job->jv_prev;
|
|
if (job->jv_prev == NULL)
|
|
first_job = job->jv_next;
|
|
else
|
|
job->jv_prev->jv_next = job->jv_next;
|
|
vim_free(job);
|
|
}
|
|
|
|
static void
|
|
job_free(job_T *job)
|
|
{
|
|
if (!in_free_unref_items)
|
|
{
|
|
job_free_contents(job);
|
|
job_free_job(job);
|
|
}
|
|
}
|
|
|
|
#if defined(EXITFREE) || defined(PROTO)
|
|
void
|
|
job_free_all(void)
|
|
{
|
|
while (first_job != NULL)
|
|
job_free(first_job);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Return TRUE if we need to check if the process of "job" has ended.
|
|
*/
|
|
static int
|
|
job_need_end_check(job_T *job)
|
|
{
|
|
return job->jv_status == JOB_STARTED
|
|
&& (job->jv_stoponexit != NULL || job->jv_exit_cb != NULL);
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if the channel of "job" is still useful.
|
|
*/
|
|
static int
|
|
job_channel_still_useful(job_T *job)
|
|
{
|
|
return job->jv_channel != NULL && channel_still_useful(job->jv_channel);
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if the job should not be freed yet. Do not free the job when
|
|
* it has not ended yet and there is a "stoponexit" flag, an exit callback
|
|
* or when the associated channel will do something with the job output.
|
|
*/
|
|
static int
|
|
job_still_useful(job_T *job)
|
|
{
|
|
return job_need_end_check(job) || job_channel_still_useful(job);
|
|
}
|
|
|
|
/*
|
|
* NOTE: Must call job_cleanup() only once right after the status of "job"
|
|
* changed to JOB_ENDED (i.e. after job_status() returned "dead" first or
|
|
* mch_detect_ended_job() returned non-NULL).
|
|
*/
|
|
static void
|
|
job_cleanup(job_T *job)
|
|
{
|
|
if (job->jv_status != JOB_ENDED)
|
|
return;
|
|
|
|
/* Ready to cleanup the job. */
|
|
job->jv_status = JOB_FINISHED;
|
|
|
|
if (job->jv_exit_cb != NULL)
|
|
{
|
|
typval_T argv[3];
|
|
typval_T rettv;
|
|
int dummy;
|
|
|
|
/* Invoke the exit callback. Make sure the refcount is > 0. */
|
|
++job->jv_refcount;
|
|
argv[0].v_type = VAR_JOB;
|
|
argv[0].vval.v_job = job;
|
|
argv[1].v_type = VAR_NUMBER;
|
|
argv[1].vval.v_number = job->jv_exitval;
|
|
call_func(job->jv_exit_cb, (int)STRLEN(job->jv_exit_cb),
|
|
&rettv, 2, argv, NULL, 0L, 0L, &dummy, TRUE,
|
|
job->jv_exit_partial, NULL);
|
|
clear_tv(&rettv);
|
|
--job->jv_refcount;
|
|
channel_need_redraw = TRUE;
|
|
}
|
|
|
|
/* Do not free the job in case the close callback of the associated channel
|
|
* isn't invoked yet and may get information by job_info(). */
|
|
if (job->jv_refcount == 0 && !job_channel_still_useful(job))
|
|
{
|
|
/* The job was already unreferenced and the associated channel was
|
|
* detached, now that it ended it can be freed. Careful: caller must
|
|
* not use "job" after this! */
|
|
job_free(job);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Mark references in jobs that are still useful.
|
|
*/
|
|
int
|
|
set_ref_in_job(int copyID)
|
|
{
|
|
int abort = FALSE;
|
|
job_T *job;
|
|
typval_T tv;
|
|
|
|
for (job = first_job; job != NULL; job = job->jv_next)
|
|
if (job_still_useful(job))
|
|
{
|
|
tv.v_type = VAR_JOB;
|
|
tv.vval.v_job = job;
|
|
abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL);
|
|
}
|
|
return abort;
|
|
}
|
|
|
|
/*
|
|
* Dereference "job". Note that after this "job" may have been freed.
|
|
*/
|
|
void
|
|
job_unref(job_T *job)
|
|
{
|
|
if (job != NULL && --job->jv_refcount <= 0)
|
|
{
|
|
/* Do not free the job if there is a channel where the close callback
|
|
* may get the job info. */
|
|
if (!job_channel_still_useful(job))
|
|
{
|
|
/* Do not free the job when it has not ended yet and there is a
|
|
* "stoponexit" flag or an exit callback. */
|
|
if (!job_need_end_check(job))
|
|
{
|
|
job_free(job);
|
|
}
|
|
else if (job->jv_channel != NULL)
|
|
{
|
|
/* Do remove the link to the channel, otherwise it hangs
|
|
* around until Vim exits. See job_free() for refcount. */
|
|
ch_log(job->jv_channel, "detaching channel from job");
|
|
job->jv_channel->ch_job = NULL;
|
|
channel_unref(job->jv_channel);
|
|
job->jv_channel = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
free_unused_jobs_contents(int copyID, int mask)
|
|
{
|
|
int did_free = FALSE;
|
|
job_T *job;
|
|
|
|
for (job = first_job; job != NULL; job = job->jv_next)
|
|
if ((job->jv_copyID & mask) != (copyID & mask)
|
|
&& !job_still_useful(job))
|
|
{
|
|
/* Free the channel and ordinary items it contains, but don't
|
|
* recurse into Lists, Dictionaries etc. */
|
|
job_free_contents(job);
|
|
did_free = TRUE;
|
|
}
|
|
return did_free;
|
|
}
|
|
|
|
void
|
|
free_unused_jobs(int copyID, int mask)
|
|
{
|
|
job_T *job;
|
|
job_T *job_next;
|
|
|
|
for (job = first_job; job != NULL; job = job_next)
|
|
{
|
|
job_next = job->jv_next;
|
|
if ((job->jv_copyID & mask) != (copyID & mask)
|
|
&& !job_still_useful(job))
|
|
{
|
|
/* Free the job struct itself. */
|
|
job_free_job(job);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Allocate a job. Sets the refcount to one and sets options default.
|
|
*/
|
|
static job_T *
|
|
job_alloc(void)
|
|
{
|
|
job_T *job;
|
|
|
|
job = (job_T *)alloc_clear(sizeof(job_T));
|
|
if (job != NULL)
|
|
{
|
|
job->jv_refcount = 1;
|
|
job->jv_stoponexit = vim_strsave((char_u *)"term");
|
|
|
|
if (first_job != NULL)
|
|
{
|
|
first_job->jv_prev = job;
|
|
job->jv_next = first_job;
|
|
}
|
|
first_job = job;
|
|
}
|
|
return job;
|
|
}
|
|
|
|
void
|
|
job_set_options(job_T *job, jobopt_T *opt)
|
|
{
|
|
if (opt->jo_set & JO_STOPONEXIT)
|
|
{
|
|
vim_free(job->jv_stoponexit);
|
|
if (opt->jo_stoponexit == NULL || *opt->jo_stoponexit == NUL)
|
|
job->jv_stoponexit = NULL;
|
|
else
|
|
job->jv_stoponexit = vim_strsave(opt->jo_stoponexit);
|
|
}
|
|
if (opt->jo_set & JO_EXIT_CB)
|
|
{
|
|
free_callback(job->jv_exit_cb, job->jv_exit_partial);
|
|
if (opt->jo_exit_cb == NULL || *opt->jo_exit_cb == NUL)
|
|
{
|
|
job->jv_exit_cb = NULL;
|
|
job->jv_exit_partial = NULL;
|
|
}
|
|
else
|
|
{
|
|
job->jv_exit_partial = opt->jo_exit_partial;
|
|
if (job->jv_exit_partial != NULL)
|
|
{
|
|
job->jv_exit_cb = opt->jo_exit_cb;
|
|
++job->jv_exit_partial->pt_refcount;
|
|
}
|
|
else
|
|
{
|
|
job->jv_exit_cb = vim_strsave(opt->jo_exit_cb);
|
|
func_ref(job->jv_exit_cb);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called when Vim is exiting: kill all jobs that have the "stoponexit" flag.
|
|
*/
|
|
void
|
|
job_stop_on_exit(void)
|
|
{
|
|
job_T *job;
|
|
|
|
for (job = first_job; job != NULL; job = job->jv_next)
|
|
if (job->jv_status == JOB_STARTED && job->jv_stoponexit != NULL)
|
|
mch_stop_job(job, job->jv_stoponexit);
|
|
}
|
|
|
|
/*
|
|
* Return TRUE when there is any job that has an exit callback and might exit,
|
|
* which means job_check_ended() should be called more often.
|
|
*/
|
|
int
|
|
has_pending_job(void)
|
|
{
|
|
job_T *job;
|
|
|
|
for (job = first_job; job != NULL; job = job->jv_next)
|
|
/* Only should check if the channel has been closed, if the channel is
|
|
* open the job won't exit. */
|
|
if (job->jv_status == JOB_STARTED && job->jv_exit_cb != NULL
|
|
&& !job_channel_still_useful(job))
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
#define MAX_CHECK_ENDED 8
|
|
|
|
/*
|
|
* Called once in a while: check if any jobs that seem useful have ended.
|
|
*/
|
|
void
|
|
job_check_ended(void)
|
|
{
|
|
int i;
|
|
|
|
if (first_job == NULL)
|
|
return;
|
|
|
|
for (i = 0; i < MAX_CHECK_ENDED; ++i)
|
|
{
|
|
/* NOTE: mch_detect_ended_job() must only return a job of which the
|
|
* status was just set to JOB_ENDED. */
|
|
job_T *job = mch_detect_ended_job(first_job);
|
|
|
|
if (job == NULL)
|
|
break;
|
|
job_cleanup(job); /* may free "job" */
|
|
}
|
|
|
|
if (channel_need_redraw)
|
|
{
|
|
channel_need_redraw = FALSE;
|
|
redraw_after_callback();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* "job_start()" function
|
|
*/
|
|
job_T *
|
|
job_start(typval_T *argvars)
|
|
{
|
|
job_T *job;
|
|
char_u *cmd = NULL;
|
|
#if defined(UNIX)
|
|
# define USE_ARGV
|
|
char **argv = NULL;
|
|
int argc = 0;
|
|
#else
|
|
garray_T ga;
|
|
#endif
|
|
jobopt_T opt;
|
|
ch_part_T part;
|
|
|
|
job = job_alloc();
|
|
if (job == NULL)
|
|
return NULL;
|
|
|
|
job->jv_status = JOB_FAILED;
|
|
#ifndef USE_ARGV
|
|
ga_init2(&ga, (int)sizeof(char*), 20);
|
|
#endif
|
|
|
|
/* Default mode is NL. */
|
|
clear_job_options(&opt);
|
|
opt.jo_mode = MODE_NL;
|
|
if (get_job_options(&argvars[1], &opt,
|
|
JO_MODE_ALL + JO_CB_ALL + JO_TIMEOUT_ALL + JO_STOPONEXIT
|
|
+ JO_EXIT_CB + JO_OUT_IO + JO_BLOCK_WRITE) == FAIL)
|
|
goto theend;
|
|
|
|
/* Check that when io is "file" that there is a file name. */
|
|
for (part = PART_OUT; part < PART_COUNT; ++part)
|
|
if ((opt.jo_set & (JO_OUT_IO << (part - PART_OUT)))
|
|
&& opt.jo_io[part] == JIO_FILE
|
|
&& (!(opt.jo_set & (JO_OUT_NAME << (part - PART_OUT)))
|
|
|| *opt.jo_io_name[part] == NUL))
|
|
{
|
|
EMSG(_("E920: _io file requires _name to be set"));
|
|
goto theend;
|
|
}
|
|
|
|
if ((opt.jo_set & JO_IN_IO) && opt.jo_io[PART_IN] == JIO_BUFFER)
|
|
{
|
|
buf_T *buf = NULL;
|
|
|
|
/* check that we can find the buffer before starting the job */
|
|
if (opt.jo_set & JO_IN_BUF)
|
|
{
|
|
buf = buflist_findnr(opt.jo_io_buf[PART_IN]);
|
|
if (buf == NULL)
|
|
EMSGN(_(e_nobufnr), (long)opt.jo_io_buf[PART_IN]);
|
|
}
|
|
else if (!(opt.jo_set & JO_IN_NAME))
|
|
{
|
|
EMSG(_("E915: in_io buffer requires in_buf or in_name to be set"));
|
|
}
|
|
else
|
|
buf = buflist_find_by_name(opt.jo_io_name[PART_IN], FALSE);
|
|
if (buf == NULL)
|
|
goto theend;
|
|
if (buf->b_ml.ml_mfp == NULL)
|
|
{
|
|
char_u numbuf[NUMBUFLEN];
|
|
char_u *s;
|
|
|
|
if (opt.jo_set & JO_IN_BUF)
|
|
{
|
|
sprintf((char *)numbuf, "%d", opt.jo_io_buf[PART_IN]);
|
|
s = numbuf;
|
|
}
|
|
else
|
|
s = opt.jo_io_name[PART_IN];
|
|
EMSG2(_("E918: buffer must be loaded: %s"), s);
|
|
goto theend;
|
|
}
|
|
job->jv_in_buf = buf;
|
|
}
|
|
|
|
job_set_options(job, &opt);
|
|
|
|
if (argvars[0].v_type == VAR_STRING)
|
|
{
|
|
/* Command is a string. */
|
|
cmd = argvars[0].vval.v_string;
|
|
if (cmd == NULL || *cmd == NUL)
|
|
{
|
|
EMSG(_(e_invarg));
|
|
goto theend;
|
|
}
|
|
#ifdef USE_ARGV
|
|
if (mch_parse_cmd(cmd, FALSE, &argv, &argc) == FAIL)
|
|
goto theend;
|
|
argv[argc] = NULL;
|
|
#endif
|
|
}
|
|
else if (argvars[0].v_type != VAR_LIST
|
|
|| argvars[0].vval.v_list == NULL
|
|
|| argvars[0].vval.v_list->lv_len < 1)
|
|
{
|
|
EMSG(_(e_invarg));
|
|
goto theend;
|
|
}
|
|
else
|
|
{
|
|
list_T *l = argvars[0].vval.v_list;
|
|
listitem_T *li;
|
|
char_u *s;
|
|
|
|
#ifdef USE_ARGV
|
|
/* Pass argv[] to mch_call_shell(). */
|
|
argv = (char **)alloc(sizeof(char *) * (l->lv_len + 1));
|
|
if (argv == NULL)
|
|
goto theend;
|
|
#endif
|
|
for (li = l->lv_first; li != NULL; li = li->li_next)
|
|
{
|
|
s = get_tv_string_chk(&li->li_tv);
|
|
if (s == NULL)
|
|
goto theend;
|
|
#ifdef USE_ARGV
|
|
argv[argc++] = (char *)s;
|
|
#else
|
|
/* Only escape when needed, double quotes are not always allowed. */
|
|
if (li != l->lv_first && vim_strpbrk(s, (char_u *)" \t\"") != NULL)
|
|
{
|
|
# ifdef WIN32
|
|
int old_ssl = p_ssl;
|
|
|
|
/* This is using CreateProcess, not cmd.exe. Always use
|
|
* double quote and backslashes. */
|
|
p_ssl = 0;
|
|
# endif
|
|
s = vim_strsave_shellescape(s, FALSE, TRUE);
|
|
# ifdef WIN32
|
|
p_ssl = old_ssl;
|
|
# endif
|
|
if (s == NULL)
|
|
goto theend;
|
|
ga_concat(&ga, s);
|
|
vim_free(s);
|
|
}
|
|
else
|
|
ga_concat(&ga, s);
|
|
if (li->li_next != NULL)
|
|
ga_append(&ga, ' ');
|
|
#endif
|
|
}
|
|
#ifdef USE_ARGV
|
|
argv[argc] = NULL;
|
|
#else
|
|
cmd = ga.ga_data;
|
|
#endif
|
|
}
|
|
|
|
#ifdef USE_ARGV
|
|
if (ch_log_active())
|
|
{
|
|
garray_T ga;
|
|
int i;
|
|
|
|
ga_init2(&ga, (int)sizeof(char), 200);
|
|
for (i = 0; i < argc; ++i)
|
|
{
|
|
if (i > 0)
|
|
ga_concat(&ga, (char_u *)" ");
|
|
ga_concat(&ga, (char_u *)argv[i]);
|
|
}
|
|
ch_logs(NULL, "Starting job: %s", (char *)ga.ga_data);
|
|
ga_clear(&ga);
|
|
}
|
|
mch_start_job(argv, job, &opt);
|
|
#else
|
|
ch_logs(NULL, "Starting job: %s", (char *)cmd);
|
|
mch_start_job((char *)cmd, job, &opt);
|
|
#endif
|
|
|
|
/* If the channel is reading from a buffer, write lines now. */
|
|
if (job->jv_channel != NULL)
|
|
channel_write_in(job->jv_channel);
|
|
|
|
theend:
|
|
#ifdef USE_ARGV
|
|
vim_free(argv);
|
|
#else
|
|
vim_free(ga.ga_data);
|
|
#endif
|
|
free_job_options(&opt);
|
|
return job;
|
|
}
|
|
|
|
/*
|
|
* Get the status of "job" and invoke the exit callback when needed.
|
|
* The returned string is not allocated.
|
|
*/
|
|
char *
|
|
job_status(job_T *job)
|
|
{
|
|
char *result;
|
|
|
|
if (job->jv_status >= JOB_ENDED)
|
|
/* No need to check, dead is dead. */
|
|
result = "dead";
|
|
else if (job->jv_status == JOB_FAILED)
|
|
result = "fail";
|
|
else
|
|
{
|
|
result = mch_job_status(job);
|
|
if (job->jv_status == JOB_ENDED)
|
|
job_cleanup(job);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Implementation of job_info().
|
|
*/
|
|
void
|
|
job_info(job_T *job, dict_T *dict)
|
|
{
|
|
dictitem_T *item;
|
|
varnumber_T nr;
|
|
|
|
dict_add_nr_str(dict, "status", 0L, (char_u *)job_status(job));
|
|
|
|
item = dictitem_alloc((char_u *)"channel");
|
|
if (item == NULL)
|
|
return;
|
|
item->di_tv.v_lock = 0;
|
|
item->di_tv.v_type = VAR_CHANNEL;
|
|
item->di_tv.vval.v_channel = job->jv_channel;
|
|
if (job->jv_channel != NULL)
|
|
++job->jv_channel->ch_refcount;
|
|
if (dict_add(dict, item) == FAIL)
|
|
dictitem_free(item);
|
|
|
|
#ifdef UNIX
|
|
nr = job->jv_pid;
|
|
#else
|
|
nr = job->jv_proc_info.dwProcessId;
|
|
#endif
|
|
dict_add_nr_str(dict, "process", nr, NULL);
|
|
|
|
dict_add_nr_str(dict, "exitval", job->jv_exitval, NULL);
|
|
dict_add_nr_str(dict, "exit_cb", 0L, job->jv_exit_cb);
|
|
dict_add_nr_str(dict, "stoponexit", 0L, job->jv_stoponexit);
|
|
}
|
|
|
|
int
|
|
job_stop(job_T *job, typval_T *argvars)
|
|
{
|
|
char_u *arg;
|
|
|
|
if (argvars[1].v_type == VAR_UNKNOWN)
|
|
arg = (char_u *)"";
|
|
else
|
|
{
|
|
arg = get_tv_string_chk(&argvars[1]);
|
|
if (arg == NULL)
|
|
{
|
|
EMSG(_(e_invarg));
|
|
return 0;
|
|
}
|
|
}
|
|
ch_logs(job->jv_channel, "Stopping job with '%s'", (char *)arg);
|
|
if (mch_stop_job(job, arg) == FAIL)
|
|
return 0;
|
|
|
|
/* Assume that "hup" does not kill the job. */
|
|
if (job->jv_channel != NULL && STRCMP(arg, "hup") != 0)
|
|
job->jv_channel->ch_job_killed = TRUE;
|
|
|
|
/* We don't try freeing the job, obviously the caller still has a
|
|
* reference to it. */
|
|
return 1;
|
|
}
|
|
|
|
#endif /* FEAT_JOB_CHANNEL */
|