blob: e66be182f7691685e73c5b0a7bc63f3f296237e3 [file] [log] [blame]
Bram Moolenaare0874f82016-01-24 20:36:41 +01001/* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 */
8
9/*
10 * Implements communication through a socket or any file handle.
11 */
12
13#include "vim.h"
14
Bram Moolenaar509ce2a2016-03-11 22:52:15 +010015#if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
Bram Moolenaare0874f82016-01-24 20:36:41 +010016
Bram Moolenaard04a0202016-01-26 23:30:18 +010017/* TRUE when netbeans is running with a GUI. */
18#ifdef FEAT_GUI
19# define CH_HAS_GUI (gui.in_use || gui.starting)
20#endif
21
22/* Note: when making changes here also adjust configure.in. */
23#ifdef WIN32
24/* WinSock API is separated from C API, thus we can't use read(), write(),
25 * errno... */
26# define SOCK_ERRNO errno = WSAGetLastError()
27# undef ECONNREFUSED
28# define ECONNREFUSED WSAECONNREFUSED
Bram Moolenaar4d919d72016-02-05 22:36:41 +010029# undef EWOULDBLOCK
30# define EWOULDBLOCK WSAEWOULDBLOCK
Bram Moolenaard42119f2016-02-28 20:51:49 +010031# undef EINPROGRESS
32# define EINPROGRESS WSAEINPROGRESS
Bram Moolenaard04a0202016-01-26 23:30:18 +010033# ifdef EINTR
34# undef EINTR
35# endif
36# define EINTR WSAEINTR
Bram Moolenaard8070362016-02-15 21:56:54 +010037# define sock_write(sd, buf, len) send((SOCKET)sd, buf, len, 0)
38# define sock_read(sd, buf, len) recv((SOCKET)sd, buf, len, 0)
39# define sock_close(sd) closesocket((SOCKET)sd)
Bram Moolenaard04a0202016-01-26 23:30:18 +010040#else
41# include <netdb.h>
42# include <netinet/in.h>
43
44# include <sys/socket.h>
45# ifdef HAVE_LIBGEN_H
46# include <libgen.h>
47# endif
48# define SOCK_ERRNO
49# define sock_write(sd, buf, len) write(sd, buf, len)
50# define sock_read(sd, buf, len) read(sd, buf, len)
51# define sock_close(sd) close(sd)
Bram Moolenaar0943a092016-02-16 13:11:17 +010052# define fd_read(fd, buf, len) read(fd, buf, len)
Bram Moolenaard8070362016-02-15 21:56:54 +010053# define fd_write(sd, buf, len) write(sd, buf, len)
54# define fd_close(sd) close(sd)
Bram Moolenaard04a0202016-01-26 23:30:18 +010055#endif
56
Bram Moolenaar187db502016-02-27 14:44:26 +010057/* Whether a redraw is needed for appending a line to a buffer. */
58static int channel_need_redraw = FALSE;
59
60
Bram Moolenaard8070362016-02-15 21:56:54 +010061#ifdef WIN32
62 static int
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +010063fd_read(sock_T fd, char *buf, size_t len)
Bram Moolenaard8070362016-02-15 21:56:54 +010064{
65 HANDLE h = (HANDLE)fd;
66 DWORD nread;
67
68 if (!ReadFile(h, buf, (DWORD)len, &nread, NULL))
69 return -1;
70 return (int)nread;
71}
72
73 static int
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +010074fd_write(sock_T fd, char *buf, size_t len)
Bram Moolenaard8070362016-02-15 21:56:54 +010075{
76 HANDLE h = (HANDLE)fd;
77 DWORD nwrite;
78
79 if (!WriteFile(h, buf, (DWORD)len, &nwrite, NULL))
80 return -1;
81 return (int)nwrite;
82}
83
84 static void
85fd_close(sock_T fd)
86{
87 HANDLE h = (HANDLE)fd;
88
89 CloseHandle(h);
90}
91#endif
Bram Moolenaare0874f82016-01-24 20:36:41 +010092
Bram Moolenaar6463ca22016-02-13 17:04:46 +010093/* Log file opened with ch_logfile(). */
94static FILE *log_fd = NULL;
Bram Moolenaar81661fb2016-02-18 22:23:34 +010095#ifdef FEAT_RELTIME
96static proftime_T log_start;
97#endif
Bram Moolenaar6463ca22016-02-13 17:04:46 +010098
99 void
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100100ch_logfile(char_u *fname, char_u *opt)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100101{
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100102 FILE *file = NULL;
103
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100104 if (log_fd != NULL)
105 fclose(log_fd);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100106
107 if (*fname != NUL)
108 {
109 file = fopen((char *)fname, *opt == 'w' ? "w" : "a");
110 if (file == NULL)
111 {
112 EMSG2(_(e_notopen), fname);
113 return;
114 }
115 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100116 log_fd = file;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100117
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100118 if (log_fd != NULL)
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100119 {
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100120 fprintf(log_fd, "==== start log session ====\n");
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100121#ifdef FEAT_RELTIME
122 profile_start(&log_start);
123#endif
124 }
125}
126
127 int
128ch_log_active()
129{
130 return log_fd != NULL;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100131}
132
133 static void
Bram Moolenaar77073442016-02-13 23:23:53 +0100134ch_log_lead(char *what, channel_T *ch)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100135{
136 if (log_fd != NULL)
137 {
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100138#ifdef FEAT_RELTIME
139 proftime_T log_now;
140
141 profile_start(&log_now);
142 profile_sub(&log_now, &log_start);
143 fprintf(log_fd, "%s ", profile_msg(&log_now));
144#endif
Bram Moolenaar77073442016-02-13 23:23:53 +0100145 if (ch != NULL)
146 fprintf(log_fd, "%son %d: ", what, ch->ch_id);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100147 else
148 fprintf(log_fd, "%s: ", what);
149 }
150}
151
Bram Moolenaard0b65022016-03-06 21:50:33 +0100152static int did_log_msg = TRUE;
153
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100154 void
Bram Moolenaar77073442016-02-13 23:23:53 +0100155ch_log(channel_T *ch, char *msg)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100156{
157 if (log_fd != NULL)
158 {
Bram Moolenaar77073442016-02-13 23:23:53 +0100159 ch_log_lead("", ch);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100160 fputs(msg, log_fd);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100161 fputc('\n', log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100162 fflush(log_fd);
Bram Moolenaard0b65022016-03-06 21:50:33 +0100163 did_log_msg = TRUE;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100164 }
165}
166
167 static void
Bram Moolenaar77073442016-02-13 23:23:53 +0100168ch_logn(channel_T *ch, char *msg, int nr)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100169{
170 if (log_fd != NULL)
171 {
Bram Moolenaar77073442016-02-13 23:23:53 +0100172 ch_log_lead("", ch);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100173 fprintf(log_fd, msg, nr);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100174 fputc('\n', log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100175 fflush(log_fd);
Bram Moolenaard0b65022016-03-06 21:50:33 +0100176 did_log_msg = TRUE;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100177 }
178}
179
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100180 void
Bram Moolenaar77073442016-02-13 23:23:53 +0100181ch_logs(channel_T *ch, char *msg, char *name)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100182{
183 if (log_fd != NULL)
184 {
Bram Moolenaar77073442016-02-13 23:23:53 +0100185 ch_log_lead("", ch);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100186 fprintf(log_fd, msg, name);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100187 fputc('\n', log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100188 fflush(log_fd);
Bram Moolenaard0b65022016-03-06 21:50:33 +0100189 did_log_msg = TRUE;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100190 }
191}
192
193 static void
Bram Moolenaar77073442016-02-13 23:23:53 +0100194ch_logsn(channel_T *ch, char *msg, char *name, int nr)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100195{
196 if (log_fd != NULL)
197 {
Bram Moolenaar77073442016-02-13 23:23:53 +0100198 ch_log_lead("", ch);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100199 fprintf(log_fd, msg, name, nr);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100200 fputc('\n', log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100201 fflush(log_fd);
Bram Moolenaard0b65022016-03-06 21:50:33 +0100202 did_log_msg = TRUE;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100203 }
204}
205
206 static void
Bram Moolenaar77073442016-02-13 23:23:53 +0100207ch_error(channel_T *ch, char *msg)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100208{
209 if (log_fd != NULL)
210 {
Bram Moolenaar77073442016-02-13 23:23:53 +0100211 ch_log_lead("ERR ", ch);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100212 fputs(msg, log_fd);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100213 fputc('\n', log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100214 fflush(log_fd);
Bram Moolenaard0b65022016-03-06 21:50:33 +0100215 did_log_msg = TRUE;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100216 }
217}
218
219 static void
Bram Moolenaar77073442016-02-13 23:23:53 +0100220ch_errorn(channel_T *ch, char *msg, int nr)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100221{
222 if (log_fd != NULL)
223 {
Bram Moolenaar77073442016-02-13 23:23:53 +0100224 ch_log_lead("ERR ", ch);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100225 fprintf(log_fd, msg, nr);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100226 fputc('\n', log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100227 fflush(log_fd);
Bram Moolenaard0b65022016-03-06 21:50:33 +0100228 did_log_msg = TRUE;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100229 }
230}
231
232 static void
Bram Moolenaar77073442016-02-13 23:23:53 +0100233ch_errors(channel_T *ch, char *msg, char *arg)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100234{
235 if (log_fd != NULL)
236 {
Bram Moolenaar77073442016-02-13 23:23:53 +0100237 ch_log_lead("ERR ", ch);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100238 fprintf(log_fd, msg, arg);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100239 fputc('\n', log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100240 fflush(log_fd);
Bram Moolenaard0b65022016-03-06 21:50:33 +0100241 did_log_msg = TRUE;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100242 }
243}
Bram Moolenaard04a0202016-01-26 23:30:18 +0100244
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100245#ifdef _WIN32
246# undef PERROR
247# define PERROR(msg) (void)emsg3((char_u *)"%s: %s", \
248 (char_u *)msg, (char_u *)strerror_win32(errno))
249
250 static char *
251strerror_win32(int eno)
252{
253 static LPVOID msgbuf = NULL;
254 char_u *ptr;
255
256 if (msgbuf)
257 LocalFree(msgbuf);
258 FormatMessage(
259 FORMAT_MESSAGE_ALLOCATE_BUFFER |
260 FORMAT_MESSAGE_FROM_SYSTEM |
261 FORMAT_MESSAGE_IGNORE_INSERTS,
262 NULL,
263 eno,
264 MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),
265 (LPTSTR) &msgbuf,
266 0,
267 NULL);
268 /* chomp \r or \n */
269 for (ptr = (char_u *)msgbuf; *ptr; ptr++)
270 switch (*ptr)
271 {
272 case '\r':
273 STRMOVE(ptr, ptr + 1);
274 ptr--;
275 break;
276 case '\n':
277 if (*(ptr + 1) == '\0')
278 *ptr = '\0';
279 else
280 *ptr = ' ';
281 break;
282 }
283 return msgbuf;
284}
285#endif
286
Bram Moolenaar77073442016-02-13 23:23:53 +0100287/*
288 * The list of all allocated channels.
289 */
290static channel_T *first_channel = NULL;
291static int next_ch_id = 0;
292
293/*
294 * Allocate a new channel. The refcount is set to 1.
295 * The channel isn't actually used until it is opened.
296 * Returns NULL if out of memory.
297 */
298 channel_T *
299add_channel(void)
Bram Moolenaare0874f82016-01-24 20:36:41 +0100300{
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100301 int part;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100302 channel_T *channel = (channel_T *)alloc_clear((int)sizeof(channel_T));
Bram Moolenaare0874f82016-01-24 20:36:41 +0100303
Bram Moolenaar77073442016-02-13 23:23:53 +0100304 if (channel == NULL)
305 return NULL;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100306
Bram Moolenaar77073442016-02-13 23:23:53 +0100307 channel->ch_id = next_ch_id++;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100308 ch_log(channel, "Created channel");
Bram Moolenaar77073442016-02-13 23:23:53 +0100309
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100310 for (part = PART_SOCK; part <= PART_IN; ++part)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100311 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100312 channel->ch_part[part].ch_fd = INVALID_FD;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100313#ifdef FEAT_GUI_X11
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100314 channel->ch_part[part].ch_inputHandler = (XtInputId)NULL;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100315#endif
316#ifdef FEAT_GUI_GTK
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100317 channel->ch_part[part].ch_inputHandler = 0;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100318#endif
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100319 channel->ch_part[part].ch_timeout = 2000;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100320 }
Bram Moolenaare0874f82016-01-24 20:36:41 +0100321
Bram Moolenaar77073442016-02-13 23:23:53 +0100322 if (first_channel != NULL)
323 {
324 first_channel->ch_prev = channel;
325 channel->ch_next = first_channel;
326 }
327 first_channel = channel;
328
329 channel->ch_refcount = 1;
330 return channel;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100331}
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100332
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100333/*
Bram Moolenaard6051b52016-02-28 15:49:03 +0100334 * Called when the refcount of a channel is zero.
Bram Moolenaar46c85432016-02-26 11:17:46 +0100335 * Return TRUE if "channel" has a callback and the associated job wasn't
336 * killed.
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100337 */
338 static int
Bram Moolenaar46c85432016-02-26 11:17:46 +0100339channel_still_useful(channel_T *channel)
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100340{
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100341 int has_sock_msg;
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100342 int has_out_msg;
343 int has_err_msg;
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100344
345 /* If the job was killed the channel is not expected to work anymore. */
Bram Moolenaar46c85432016-02-26 11:17:46 +0100346 if (channel->ch_job_killed && channel->ch_job == NULL)
347 return FALSE;
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100348
349 /* If there is a close callback it may still need to be invoked. */
350 if (channel->ch_close_cb != NULL)
351 return TRUE;
352
353 /* If there is no callback then nobody can get readahead. If the fd is
354 * closed and there is no readahead then the callback won't be called. */
355 has_sock_msg = channel->ch_part[PART_SOCK].ch_fd != INVALID_FD
356 || channel->ch_part[PART_SOCK].ch_head.rq_next != NULL
357 || channel->ch_part[PART_SOCK].ch_json_head.jq_next != NULL;
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100358 has_out_msg = channel->ch_part[PART_OUT].ch_fd != INVALID_FD
359 || channel->ch_part[PART_OUT].ch_head.rq_next != NULL
360 || channel->ch_part[PART_OUT].ch_json_head.jq_next != NULL;
361 has_err_msg = channel->ch_part[PART_ERR].ch_fd != INVALID_FD
362 || channel->ch_part[PART_ERR].ch_head.rq_next != NULL
363 || channel->ch_part[PART_ERR].ch_json_head.jq_next != NULL;
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100364 return (channel->ch_callback != NULL && (has_sock_msg
Bram Moolenaar509ce2a2016-03-11 22:52:15 +0100365 || has_out_msg || has_err_msg))
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100366 || (channel->ch_part[PART_OUT].ch_callback != NULL && has_out_msg)
Bram Moolenaar509ce2a2016-03-11 22:52:15 +0100367 || (channel->ch_part[PART_ERR].ch_callback != NULL && has_err_msg);
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100368}
369
370/*
371 * Close a channel and free all its resources if there is no further action
Bram Moolenaar46c85432016-02-26 11:17:46 +0100372 * possible, there is no callback to be invoked or the associated job was
373 * killed.
Bram Moolenaar70765942016-02-28 19:28:59 +0100374 * Return TRUE if the channel was freed.
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100375 */
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100376 static int
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100377channel_may_free(channel_T *channel)
378{
Bram Moolenaar46c85432016-02-26 11:17:46 +0100379 if (!channel_still_useful(channel))
Bram Moolenaar70765942016-02-28 19:28:59 +0100380 {
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100381 channel_free(channel);
Bram Moolenaar70765942016-02-28 19:28:59 +0100382 return TRUE;
383 }
384 return FALSE;
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100385}
386
387/*
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100388 * Decrement the reference count on "channel" and maybe free it when it goes
389 * down to zero. Don't free it if there is a pending action.
390 * Returns TRUE when the channel is no longer referenced.
391 */
392 int
393channel_unref(channel_T *channel)
394{
395 if (channel != NULL && --channel->ch_refcount <= 0)
396 return channel_may_free(channel);
397 return FALSE;
398}
399
400/*
Bram Moolenaar77073442016-02-13 23:23:53 +0100401 * Close a channel and free all its resources.
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100402 */
Bram Moolenaar77073442016-02-13 23:23:53 +0100403 void
404channel_free(channel_T *channel)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100405{
Bram Moolenaar8b374212016-02-24 20:43:06 +0100406 channel_close(channel, TRUE);
Bram Moolenaar187db502016-02-27 14:44:26 +0100407 channel_clear(channel);
Bram Moolenaard6051b52016-02-28 15:49:03 +0100408 ch_log(channel, "Freeing channel");
Bram Moolenaar77073442016-02-13 23:23:53 +0100409 if (channel->ch_next != NULL)
410 channel->ch_next->ch_prev = channel->ch_prev;
411 if (channel->ch_prev == NULL)
412 first_channel = channel->ch_next;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100413 else
Bram Moolenaar77073442016-02-13 23:23:53 +0100414 channel->ch_prev->ch_next = channel->ch_next;
415 vim_free(channel);
Bram Moolenaare0874f82016-01-24 20:36:41 +0100416}
417
Bram Moolenaard04a0202016-01-26 23:30:18 +0100418#if defined(FEAT_GUI) || defined(PROTO)
Bram Moolenaar77073442016-02-13 23:23:53 +0100419
420#if defined(FEAT_GUI_X11) || defined(FEAT_GUI_GTK)
421 static void
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100422channel_read_fd(int fd)
Bram Moolenaar77073442016-02-13 23:23:53 +0100423{
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100424 channel_T *channel;
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100425 int part;
Bram Moolenaar77073442016-02-13 23:23:53 +0100426
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100427 channel = channel_fd2channel(fd, &part);
Bram Moolenaar77073442016-02-13 23:23:53 +0100428 if (channel == NULL)
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100429 ch_errorn(NULL, "Channel for fd %d not found", fd);
Bram Moolenaar77073442016-02-13 23:23:53 +0100430 else
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100431 channel_read(channel, part, "messageFromNetbeans");
Bram Moolenaar77073442016-02-13 23:23:53 +0100432}
433#endif
434
Bram Moolenaare0874f82016-01-24 20:36:41 +0100435/*
Bram Moolenaard04a0202016-01-26 23:30:18 +0100436 * Read a command from netbeans.
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100437 * TODO: instead of channel ID use the FD.
Bram Moolenaare0874f82016-01-24 20:36:41 +0100438 */
Bram Moolenaard04a0202016-01-26 23:30:18 +0100439#ifdef FEAT_GUI_X11
440 static void
441messageFromNetbeans(XtPointer clientData,
442 int *unused1 UNUSED,
443 XtInputId *unused2 UNUSED)
Bram Moolenaare0874f82016-01-24 20:36:41 +0100444{
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100445 channel_read_fd((int)(long)clientData);
Bram Moolenaare0874f82016-01-24 20:36:41 +0100446}
Bram Moolenaard04a0202016-01-26 23:30:18 +0100447#endif
Bram Moolenaare0874f82016-01-24 20:36:41 +0100448
Bram Moolenaard04a0202016-01-26 23:30:18 +0100449#ifdef FEAT_GUI_GTK
Bram Moolenaar98921892016-02-23 17:14:37 +0100450# if GTK_CHECK_VERSION(3,0,0)
451 static gboolean
452messageFromNetbeans(GIOChannel *unused1 UNUSED,
453 GIOCondition unused2 UNUSED,
454 gpointer clientData)
455{
456 channel_read_fd(GPOINTER_TO_INT(clientData));
457 return TRUE; /* Return FALSE instead in case the event source is to
458 * be removed after this function returns. */
459}
460# else
Bram Moolenaard04a0202016-01-26 23:30:18 +0100461 static void
462messageFromNetbeans(gpointer clientData,
463 gint unused1 UNUSED,
464 GdkInputCondition unused2 UNUSED)
Bram Moolenaare0874f82016-01-24 20:36:41 +0100465{
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100466 channel_read_fd((int)(long)clientData);
Bram Moolenaare0874f82016-01-24 20:36:41 +0100467}
Bram Moolenaar98921892016-02-23 17:14:37 +0100468# endif
Bram Moolenaare0874f82016-01-24 20:36:41 +0100469#endif
470
471 static void
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100472channel_gui_register_one(channel_T *channel, int part)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100473{
Bram Moolenaarde279892016-03-11 22:19:44 +0100474 if (!CH_HAS_GUI)
475 return;
476
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100477# ifdef FEAT_GUI_X11
478 /* Tell notifier we are interested in being called
479 * when there is input on the editor connection socket. */
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100480 if (channel->ch_part[part].ch_inputHandler == (XtInputId)NULL)
481 channel->ch_part[part].ch_inputHandler = XtAppAddInput(
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100482 (XtAppContext)app_context,
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100483 channel->ch_part[part].ch_fd,
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100484 (XtPointer)(XtInputReadMask + XtInputExceptMask),
485 messageFromNetbeans,
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100486 (XtPointer)(long)channel->ch_part[part].ch_fd);
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100487# else
488# ifdef FEAT_GUI_GTK
489 /* Tell gdk we are interested in being called when there
490 * is input on the editor connection socket. */
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100491 if (channel->ch_part[part].ch_inputHandler == 0)
Bram Moolenaar98921892016-02-23 17:14:37 +0100492# if GTK_CHECK_VERSION(3,0,0)
493 {
494 GIOChannel *chnnl = g_io_channel_unix_new(
495 (gint)channel->ch_part[part].ch_fd);
496
497 channel->ch_part[part].ch_inputHandler = g_io_add_watch(
498 chnnl,
499 G_IO_IN|G_IO_HUP|G_IO_ERR|G_IO_PRI,
500 messageFromNetbeans,
501 GINT_TO_POINTER(channel->ch_part[part].ch_fd));
502
503 g_io_channel_unref(chnnl);
504 }
505# else
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100506 channel->ch_part[part].ch_inputHandler = gdk_input_add(
507 (gint)channel->ch_part[part].ch_fd,
Bram Moolenaar16eb4f82016-02-14 23:02:34 +0100508 (GdkInputCondition)
509 ((int)GDK_INPUT_READ + (int)GDK_INPUT_EXCEPTION),
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100510 messageFromNetbeans,
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100511 (gpointer)(long)channel->ch_part[part].ch_fd);
Bram Moolenaar98921892016-02-23 17:14:37 +0100512# endif
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100513# endif
514# endif
515}
516
Bram Moolenaarde279892016-03-11 22:19:44 +0100517 static void
Bram Moolenaar77073442016-02-13 23:23:53 +0100518channel_gui_register(channel_T *channel)
Bram Moolenaare0874f82016-01-24 20:36:41 +0100519{
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100520 if (channel->CH_SOCK_FD != INVALID_FD)
521 channel_gui_register_one(channel, PART_SOCK);
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100522 if (channel->CH_OUT_FD != INVALID_FD)
523 channel_gui_register_one(channel, PART_OUT);
524 if (channel->CH_ERR_FD != INVALID_FD)
525 channel_gui_register_one(channel, PART_ERR);
Bram Moolenaard04a0202016-01-26 23:30:18 +0100526}
527
528/*
529 * Register any of our file descriptors with the GUI event handling system.
530 * Called when the GUI has started.
531 */
532 void
533channel_gui_register_all(void)
534{
Bram Moolenaar77073442016-02-13 23:23:53 +0100535 channel_T *channel;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100536
Bram Moolenaar77073442016-02-13 23:23:53 +0100537 for (channel = first_channel; channel != NULL; channel = channel->ch_next)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100538 channel_gui_register(channel);
539}
540
541 static void
Bram Moolenaarde279892016-03-11 22:19:44 +0100542channel_gui_unregister_one(channel_T *channel, int part)
543{
544# ifdef FEAT_GUI_X11
545 if (channel->ch_part[part].ch_inputHandler != (XtInputId)NULL)
546 {
547 XtRemoveInput(channel->ch_part[part].ch_inputHandler);
548 channel->ch_part[part].ch_inputHandler = (XtInputId)NULL;
549 }
550# else
551# ifdef FEAT_GUI_GTK
552 if (channel->ch_part[part].ch_inputHandler != 0)
553 {
554# if GTK_CHECK_VERSION(3,0,0)
555 g_source_remove(channel->ch_part[part].ch_inputHandler);
556# else
557 gdk_input_remove(channel->ch_part[part].ch_inputHandler);
558# endif
559 channel->ch_part[part].ch_inputHandler = 0;
560 }
561# endif
562# endif
563}
564
565 static void
Bram Moolenaar16eb4f82016-02-14 23:02:34 +0100566channel_gui_unregister(channel_T *channel)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100567{
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100568 int part;
Bram Moolenaar16eb4f82016-02-14 23:02:34 +0100569
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100570 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaarde279892016-03-11 22:19:44 +0100571 channel_gui_unregister_one(channel, part);
Bram Moolenaard04a0202016-01-26 23:30:18 +0100572}
573
574#endif
575
Bram Moolenaare74e8e72016-02-16 22:01:30 +0100576static char *e_cannot_connect = N_("E902: Cannot connect to port");
577
Bram Moolenaard04a0202016-01-26 23:30:18 +0100578/*
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100579 * Open a socket channel to "hostname":"port".
Bram Moolenaare74e8e72016-02-16 22:01:30 +0100580 * "waittime" is the time in msec to wait for the connection.
581 * When negative wait forever.
Bram Moolenaar77073442016-02-13 23:23:53 +0100582 * Returns the channel for success.
583 * Returns NULL for failure.
Bram Moolenaard04a0202016-01-26 23:30:18 +0100584 */
Bram Moolenaar77073442016-02-13 23:23:53 +0100585 channel_T *
Bram Moolenaar4e221c92016-02-23 13:20:22 +0100586channel_open(
587 char *hostname,
588 int port_in,
589 int waittime,
590 void (*nb_close_cb)(void))
Bram Moolenaard04a0202016-01-26 23:30:18 +0100591{
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100592 int sd = -1;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100593 struct sockaddr_in server;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100594 struct hostent *host;
Bram Moolenaarf12d9832016-01-29 21:11:25 +0100595#ifdef WIN32
Bram Moolenaard04a0202016-01-26 23:30:18 +0100596 u_short port = port_in;
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100597 u_long val = 1;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100598#else
599 int port = port_in;
600#endif
Bram Moolenaar77073442016-02-13 23:23:53 +0100601 channel_T *channel;
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100602 int ret;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100603
Bram Moolenaarf12d9832016-01-29 21:11:25 +0100604#ifdef WIN32
Bram Moolenaard04a0202016-01-26 23:30:18 +0100605 channel_init_winsock();
606#endif
607
Bram Moolenaar77073442016-02-13 23:23:53 +0100608 channel = add_channel();
609 if (channel == NULL)
Bram Moolenaard04a0202016-01-26 23:30:18 +0100610 {
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100611 ch_error(NULL, "Cannot allocate channel.");
Bram Moolenaar77073442016-02-13 23:23:53 +0100612 return NULL;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100613 }
614
615 /* Get the server internet address and put into addr structure */
616 /* fill in the socket address structure and connect to server */
617 vim_memset((char *)&server, 0, sizeof(server));
618 server.sin_family = AF_INET;
619 server.sin_port = htons(port);
620 if ((host = gethostbyname(hostname)) == NULL)
621 {
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100622 ch_error(channel, "in gethostbyname() in channel_open()");
Bram Moolenaarfb1f6262016-01-31 20:24:32 +0100623 PERROR("E901: gethostbyname() in channel_open()");
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100624 channel_free(channel);
Bram Moolenaar77073442016-02-13 23:23:53 +0100625 return NULL;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100626 }
627 memcpy((char *)&server.sin_addr, host->h_addr, host->h_length);
628
Bram Moolenaar254e00d2016-02-19 23:23:12 +0100629 /* On Mac and Solaris a zero timeout almost never works. At least wait
630 * one millisecond. Let's do it for all systems, because we don't know why
631 * this is needed. */
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100632 if (waittime == 0)
633 waittime = 1;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100634
635 /*
636 * For Unix we need to call connect() again after connect() failed.
637 * On Win32 one time is sufficient.
638 */
639 while (TRUE)
640 {
Bram Moolenaar562ca712016-03-09 21:50:05 +0100641 long elapsed_msec = 0;
642 int waitnow;
Bram Moolenaar045a2842016-03-08 22:33:07 +0100643
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100644 if (sd >= 0)
Bram Moolenaard04a0202016-01-26 23:30:18 +0100645 sock_close(sd);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100646 sd = socket(AF_INET, SOCK_STREAM, 0);
647 if (sd == -1)
648 {
649 ch_error(channel, "in socket() in channel_open().");
650 PERROR("E898: socket() in channel_open()");
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100651 channel_free(channel);
Bram Moolenaar77073442016-02-13 23:23:53 +0100652 return NULL;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100653 }
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100654
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100655 if (waittime >= 0)
656 {
657 /* Make connect() non-blocking. */
658 if (
659#ifdef _WIN32
660 ioctlsocket(sd, FIONBIO, &val) < 0
661#else
662 fcntl(sd, F_SETFL, O_NONBLOCK) < 0
663#endif
664 )
665 {
666 SOCK_ERRNO;
667 ch_errorn(channel,
668 "channel_open: Connect failed with errno %d", errno);
669 sock_close(sd);
670 channel_free(channel);
671 return NULL;
672 }
673 }
674
675 /* Try connecting to the server. */
676 ch_logsn(channel, "Connecting to %s port %d", hostname, port);
677 ret = connect(sd, (struct sockaddr *)&server, sizeof(server));
678
Bram Moolenaar045a2842016-03-08 22:33:07 +0100679 if (ret == 0)
680 /* The connection could be established. */
681 break;
682
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100683 SOCK_ERRNO;
Bram Moolenaar045a2842016-03-08 22:33:07 +0100684 if (waittime < 0 || (errno != EWOULDBLOCK
685 && errno != ECONNREFUSED
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100686#ifdef EINPROGRESS
Bram Moolenaar045a2842016-03-08 22:33:07 +0100687 && errno != EINPROGRESS
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100688#endif
Bram Moolenaar045a2842016-03-08 22:33:07 +0100689 ))
690 {
691 ch_errorn(channel,
692 "channel_open: Connect failed with errno %d", errno);
693 PERROR(_(e_cannot_connect));
694 sock_close(sd);
695 channel_free(channel);
696 return NULL;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100697 }
Bram Moolenaard04a0202016-01-26 23:30:18 +0100698
Bram Moolenaar40e8cb22016-03-10 21:10:58 +0100699 /* Limit the waittime to 50 msec. If it doesn't work within this
700 * time we close the socket and try creating it again. */
701 waitnow = waittime > 50 ? 50 : waittime;
702
Bram Moolenaar045a2842016-03-08 22:33:07 +0100703 /* If connect() didn't finish then try using select() to wait for the
Bram Moolenaar562ca712016-03-09 21:50:05 +0100704 * connection to be made. For Win32 always use select() to wait. */
Bram Moolenaar045a2842016-03-08 22:33:07 +0100705#ifndef WIN32
706 if (errno != ECONNREFUSED)
707#endif
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100708 {
709 struct timeval tv;
Bram Moolenaard42119f2016-02-28 20:51:49 +0100710 fd_set rfds;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100711 fd_set wfds;
Bram Moolenaare081e212016-02-28 22:33:46 +0100712#ifndef WIN32
Bram Moolenaard42119f2016-02-28 20:51:49 +0100713 int so_error = 0;
714 socklen_t so_error_len = sizeof(so_error);
Bram Moolenaar045a2842016-03-08 22:33:07 +0100715 struct timeval start_tv;
716 struct timeval end_tv;
Bram Moolenaare081e212016-02-28 22:33:46 +0100717#endif
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100718 FD_ZERO(&rfds);
719 FD_SET(sd, &rfds);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100720 FD_ZERO(&wfds);
721 FD_SET(sd, &wfds);
Bram Moolenaare74e8e72016-02-16 22:01:30 +0100722
Bram Moolenaar562ca712016-03-09 21:50:05 +0100723 tv.tv_sec = waitnow / 1000;
724 tv.tv_usec = (waitnow % 1000) * 1000;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100725#ifndef WIN32
726 gettimeofday(&start_tv, NULL);
727#endif
728 ch_logn(channel,
Bram Moolenaar562ca712016-03-09 21:50:05 +0100729 "Waiting for connection (waiting %d msec)...", waitnow);
Bram Moolenaard42119f2016-02-28 20:51:49 +0100730 ret = select((int)sd + 1, &rfds, &wfds, NULL, &tv);
Bram Moolenaare74e8e72016-02-16 22:01:30 +0100731
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100732 if (ret < 0)
733 {
734 SOCK_ERRNO;
735 ch_errorn(channel,
736 "channel_open: Connect failed with errno %d", errno);
737 PERROR(_(e_cannot_connect));
738 sock_close(sd);
739 channel_free(channel);
740 return NULL;
741 }
Bram Moolenaard42119f2016-02-28 20:51:49 +0100742
Bram Moolenaare081e212016-02-28 22:33:46 +0100743#ifdef WIN32
Bram Moolenaar562ca712016-03-09 21:50:05 +0100744 /* On Win32: select() is expected to work and wait for up to
745 * "waitnow" msec for the socket to be open. */
Bram Moolenaar045a2842016-03-08 22:33:07 +0100746 if (FD_ISSET(sd, &wfds))
747 break;
Bram Moolenaar562ca712016-03-09 21:50:05 +0100748 elapsed_msec = waitnow;
749 if (waittime > 1 && elapsed_msec < waittime)
750 {
751 waittime -= elapsed_msec;
752 continue;
753 }
Bram Moolenaare081e212016-02-28 22:33:46 +0100754#else
755 /* On Linux-like systems: See socket(7) for the behavior
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100756 * After putting the socket in non-blocking mode, connect() will
757 * return EINPROGRESS, select() will not wait (as if writing is
758 * possible), need to use getsockopt() to check if the socket is
Bram Moolenaar42bc6dd2016-03-02 20:48:47 +0100759 * actually able to connect.
Bram Moolenaar045a2842016-03-08 22:33:07 +0100760 * We detect a failure to connect when either read and write fds
Bram Moolenaard42119f2016-02-28 20:51:49 +0100761 * are set. Use getsockopt() to find out what kind of failure. */
Bram Moolenaar42bc6dd2016-03-02 20:48:47 +0100762 if (FD_ISSET(sd, &rfds) || FD_ISSET(sd, &wfds))
Bram Moolenaard42119f2016-02-28 20:51:49 +0100763 {
764 ret = getsockopt(sd,
Bram Moolenaar045a2842016-03-08 22:33:07 +0100765 SOL_SOCKET, SO_ERROR, &so_error, &so_error_len);
Bram Moolenaard42119f2016-02-28 20:51:49 +0100766 if (ret < 0 || (so_error != 0
767 && so_error != EWOULDBLOCK
768 && so_error != ECONNREFUSED
Bram Moolenaare081e212016-02-28 22:33:46 +0100769# ifdef EINPROGRESS
Bram Moolenaard42119f2016-02-28 20:51:49 +0100770 && so_error != EINPROGRESS
Bram Moolenaare081e212016-02-28 22:33:46 +0100771# endif
Bram Moolenaard42119f2016-02-28 20:51:49 +0100772 ))
773 {
774 ch_errorn(channel,
775 "channel_open: Connect failed with errno %d",
776 so_error);
777 PERROR(_(e_cannot_connect));
778 sock_close(sd);
779 channel_free(channel);
780 return NULL;
781 }
782 }
783
Bram Moolenaar045a2842016-03-08 22:33:07 +0100784 if (FD_ISSET(sd, &wfds) && so_error == 0)
785 /* Did not detect an error, connection is established. */
786 break;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100787
Bram Moolenaar045a2842016-03-08 22:33:07 +0100788 gettimeofday(&end_tv, NULL);
789 elapsed_msec = (end_tv.tv_sec - start_tv.tv_sec) * 1000
790 + (end_tv.tv_usec - start_tv.tv_usec) / 1000;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100791#endif
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100792 }
Bram Moolenaar045a2842016-03-08 22:33:07 +0100793
794#ifndef WIN32
795 if (waittime > 1 && elapsed_msec < waittime)
796 {
797 /* The port isn't ready but we also didn't get an error.
798 * This happens when the server didn't open the socket
Bram Moolenaar562ca712016-03-09 21:50:05 +0100799 * yet. Select() may return early, wait until the remaining
800 * "waitnow" and try again. */
801 waitnow -= elapsed_msec;
802 waittime -= elapsed_msec;
803 if (waitnow > 0)
804 {
805 mch_delay((long)waitnow, TRUE);
806 ui_breakcheck();
807 waittime -= waitnow;
808 }
Bram Moolenaar045a2842016-03-08 22:33:07 +0100809 if (!got_int)
810 {
Bram Moolenaar562ca712016-03-09 21:50:05 +0100811 if (waittime <= 0)
812 /* give it one more try */
Bram Moolenaar045a2842016-03-08 22:33:07 +0100813 waittime = 1;
814 continue;
815 }
816 /* we were interrupted, behave as if timed out */
817 }
818#endif
819
820 /* We timed out. */
821 ch_error(channel, "Connection timed out");
822 sock_close(sd);
823 channel_free(channel);
824 return NULL;
Bram Moolenaar7a84dbe2016-02-07 21:29:00 +0100825 }
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100826
Bram Moolenaar045a2842016-03-08 22:33:07 +0100827 ch_log(channel, "Connection made");
828
Bram Moolenaar7a84dbe2016-02-07 21:29:00 +0100829 if (waittime >= 0)
830 {
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100831#ifdef _WIN32
832 val = 0;
833 ioctlsocket(sd, FIONBIO, &val);
834#else
Bram Moolenaarfbc4b4d2016-02-07 15:14:01 +0100835 (void)fcntl(sd, F_SETFL, 0);
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100836#endif
837 }
838
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100839 channel->CH_SOCK_FD = (sock_T)sd;
Bram Moolenaar4e221c92016-02-23 13:20:22 +0100840 channel->ch_nb_close_cb = nb_close_cb;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100841
842#ifdef FEAT_GUI
Bram Moolenaarde279892016-03-11 22:19:44 +0100843 channel_gui_register_one(channel, PART_SOCK);
Bram Moolenaard04a0202016-01-26 23:30:18 +0100844#endif
845
Bram Moolenaar77073442016-02-13 23:23:53 +0100846 return channel;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100847}
848
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100849/*
850 * Implements ch_open().
851 */
852 channel_T *
853channel_open_func(typval_T *argvars)
854{
855 char_u *address;
856 char_u *p;
857 char *rest;
858 int port;
859 jobopt_T opt;
860 channel_T *channel;
861
862 address = get_tv_string(&argvars[0]);
863 if (argvars[1].v_type != VAR_UNKNOWN
864 && (argvars[1].v_type != VAR_DICT || argvars[1].vval.v_dict == NULL))
865 {
866 EMSG(_(e_invarg));
867 return NULL;
868 }
869
870 /* parse address */
871 p = vim_strchr(address, ':');
872 if (p == NULL)
873 {
874 EMSG2(_(e_invarg2), address);
875 return NULL;
876 }
877 *p++ = NUL;
878 port = strtol((char *)p, &rest, 10);
879 if (*address == NUL || port <= 0 || *rest != NUL)
880 {
881 p[-1] = ':';
882 EMSG2(_(e_invarg2), address);
883 return NULL;
884 }
885
886 /* parse options */
887 clear_job_options(&opt);
888 opt.jo_mode = MODE_JSON;
889 opt.jo_timeout = 2000;
890 if (get_job_options(&argvars[1], &opt,
891 JO_MODE_ALL + JO_CB_ALL + JO_WAITTIME + JO_TIMEOUT_ALL) == FAIL)
892 return NULL;
893 if (opt.jo_timeout < 0)
894 {
895 EMSG(_(e_invarg));
896 return NULL;
897 }
898
899 channel = channel_open((char *)address, port, opt.jo_waittime, NULL);
900 if (channel != NULL)
901 {
902 opt.jo_set = JO_ALL;
903 channel_set_options(channel, &opt);
904 }
905 return channel;
906}
907
Bram Moolenaarde279892016-03-11 22:19:44 +0100908 static void
909may_close_part(sock_T *fd)
910{
911 if (*fd != INVALID_FD)
912 {
913 fd_close(*fd);
914 *fd = INVALID_FD;
915 }
916}
917
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100918 void
Bram Moolenaard8070362016-02-15 21:56:54 +0100919channel_set_pipes(channel_T *channel, sock_T in, sock_T out, sock_T err)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100920{
Bram Moolenaarde279892016-03-11 22:19:44 +0100921 if (in != INVALID_FD)
922 {
923 may_close_part(&channel->CH_IN_FD);
924 channel->CH_IN_FD = in;
925 }
926 if (out != INVALID_FD)
927 {
928# if defined(FEAT_GUI)
929 channel_gui_unregister_one(channel, PART_OUT);
930# endif
931 may_close_part(&channel->CH_OUT_FD);
932 channel->CH_OUT_FD = out;
933# if defined(FEAT_GUI)
934 channel_gui_register_one(channel, PART_OUT);
935# endif
936 }
937 if (err != INVALID_FD)
938 {
939# if defined(FEAT_GUI)
940 channel_gui_unregister_one(channel, PART_ERR);
941# endif
942 may_close_part(&channel->CH_ERR_FD);
943 channel->CH_ERR_FD = err;
944# if defined(FEAT_GUI)
945 channel_gui_register_one(channel, PART_ERR);
946# endif
947 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100948}
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100949
Bram Moolenaard6051b52016-02-28 15:49:03 +0100950/*
Bram Moolenaar014069a2016-03-03 22:51:40 +0100951 * Sets the job the channel is associated with and associated options.
Bram Moolenaard6051b52016-02-28 15:49:03 +0100952 * This does not keep a refcount, when the job is freed ch_job is cleared.
953 */
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100954 void
Bram Moolenaar014069a2016-03-03 22:51:40 +0100955channel_set_job(channel_T *channel, job_T *job, jobopt_T *options)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100956{
Bram Moolenaar77073442016-02-13 23:23:53 +0100957 channel->ch_job = job;
Bram Moolenaar014069a2016-03-03 22:51:40 +0100958
959 channel_set_options(channel, options);
960
961 if (job->jv_in_buf != NULL)
962 {
963 chanpart_T *in_part = &channel->ch_part[PART_IN];
964
965 in_part->ch_buffer = job->jv_in_buf;
966 ch_logs(channel, "reading from buffer '%s'",
967 (char *)in_part->ch_buffer->b_ffname);
968 if (options->jo_set & JO_IN_TOP)
Bram Moolenaar99ef0622016-03-06 20:22:25 +0100969 {
970 if (options->jo_in_top == 0 && !(options->jo_set & JO_IN_BOT))
971 {
972 /* Special mode: send last-but-one line when appending a line
973 * to the buffer. */
974 in_part->ch_buffer->b_write_to_channel = TRUE;
975 in_part->ch_buf_top =
976 in_part->ch_buffer->b_ml.ml_line_count + 1;
977 }
978 else
979 in_part->ch_buf_top = options->jo_in_top;
980 }
Bram Moolenaar014069a2016-03-03 22:51:40 +0100981 else
982 in_part->ch_buf_top = 1;
983 if (options->jo_set & JO_IN_BOT)
984 in_part->ch_buf_bot = options->jo_in_bot;
985 else
986 in_part->ch_buf_bot = in_part->ch_buffer->b_ml.ml_line_count;
987 }
Bram Moolenaard04a0202016-01-26 23:30:18 +0100988}
989
990/*
Bram Moolenaar187db502016-02-27 14:44:26 +0100991 * Find a buffer matching "name" or create a new one.
992 */
993 static buf_T *
Bram Moolenaar6ff02c92016-03-08 20:12:44 +0100994find_buffer(char_u *name, int err)
Bram Moolenaar187db502016-02-27 14:44:26 +0100995{
Bram Moolenaarc7f0ebc2016-02-27 21:10:09 +0100996 buf_T *buf = NULL;
Bram Moolenaar187db502016-02-27 14:44:26 +0100997 buf_T *save_curbuf = curbuf;
998
Bram Moolenaarc7f0ebc2016-02-27 21:10:09 +0100999 if (name != NULL && *name != NUL)
1000 buf = buflist_findname(name);
Bram Moolenaar187db502016-02-27 14:44:26 +01001001 if (buf == NULL)
1002 {
Bram Moolenaare26643e2016-02-27 21:53:02 +01001003 buf = buflist_new(name == NULL || *name == NUL ? NULL : name,
Bram Moolenaarc7f0ebc2016-02-27 21:10:09 +01001004 NULL, (linenr_T)0, BLN_LISTED);
Bram Moolenaar187db502016-02-27 14:44:26 +01001005 buf_copy_options(buf, BCO_ENTER);
1006#ifdef FEAT_QUICKFIX
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001007 set_option_value((char_u *)"bt", 0L, (char_u *)"nofile", OPT_LOCAL);
1008 set_option_value((char_u *)"bh", 0L, (char_u *)"hide", OPT_LOCAL);
Bram Moolenaar187db502016-02-27 14:44:26 +01001009#endif
1010 curbuf = buf;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001011 if (curbuf->b_ml.ml_mfp == NULL)
1012 ml_open(curbuf);
Bram Moolenaar6ff02c92016-03-08 20:12:44 +01001013 ml_replace(1, (char_u *)(err ? "Reading from channel error..."
1014 : "Reading from channel output..."), TRUE);
Bram Moolenaar187db502016-02-27 14:44:26 +01001015 changed_bytes(1, 0);
1016 curbuf = save_curbuf;
1017 }
1018
1019 return buf;
1020}
1021
1022/*
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001023 * Set various properties from an "opt" argument.
Bram Moolenaar910b8aa2016-02-16 21:03:07 +01001024 */
1025 void
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001026channel_set_options(channel_T *channel, jobopt_T *opt)
Bram Moolenaar910b8aa2016-02-16 21:03:07 +01001027{
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001028 int part;
1029 char_u **cbp;
1030 partial_T **pp;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001031
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001032 if (opt->jo_set & JO_MODE)
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001033 for (part = PART_SOCK; part <= PART_IN; ++part)
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001034 channel->ch_part[part].ch_mode = opt->jo_mode;
1035 if (opt->jo_set & JO_IN_MODE)
1036 channel->ch_part[PART_IN].ch_mode = opt->jo_in_mode;
1037 if (opt->jo_set & JO_OUT_MODE)
1038 channel->ch_part[PART_OUT].ch_mode = opt->jo_out_mode;
1039 if (opt->jo_set & JO_ERR_MODE)
1040 channel->ch_part[PART_ERR].ch_mode = opt->jo_err_mode;
Bram Moolenaar910b8aa2016-02-16 21:03:07 +01001041
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001042 if (opt->jo_set & JO_TIMEOUT)
1043 for (part = PART_SOCK; part <= PART_IN; ++part)
1044 channel->ch_part[part].ch_timeout = opt->jo_timeout;
1045 if (opt->jo_set & JO_OUT_TIMEOUT)
1046 channel->ch_part[PART_OUT].ch_timeout = opt->jo_out_timeout;
1047 if (opt->jo_set & JO_ERR_TIMEOUT)
1048 channel->ch_part[PART_ERR].ch_timeout = opt->jo_err_timeout;
1049
1050 if (opt->jo_set & JO_CALLBACK)
Bram Moolenaar0ba75a92016-02-19 23:21:26 +01001051 {
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001052 cbp = &channel->ch_callback;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001053 pp = &channel->ch_partial;
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001054 vim_free(*cbp);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001055 partial_unref(*pp);
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001056 if (opt->jo_callback != NULL && *opt->jo_callback != NUL)
1057 *cbp = vim_strsave(opt->jo_callback);
Bram Moolenaar0ba75a92016-02-19 23:21:26 +01001058 else
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001059 *cbp = NULL;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001060 *pp = opt->jo_partial;
1061 if (*pp != NULL)
1062 ++(*pp)->pt_refcount;
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001063 }
1064 if (opt->jo_set & JO_OUT_CALLBACK)
1065 {
1066 cbp = &channel->ch_part[PART_OUT].ch_callback;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001067 pp = &channel->ch_part[PART_OUT].ch_partial;
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001068 vim_free(*cbp);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001069 partial_unref(*pp);
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001070 if (opt->jo_out_cb != NULL && *opt->jo_out_cb != NUL)
1071 *cbp = vim_strsave(opt->jo_out_cb);
1072 else
1073 *cbp = NULL;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001074 *pp = opt->jo_out_partial;
1075 if (*pp != NULL)
1076 ++(*pp)->pt_refcount;
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001077 }
1078 if (opt->jo_set & JO_ERR_CALLBACK)
1079 {
1080 cbp = &channel->ch_part[PART_ERR].ch_callback;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001081 pp = &channel->ch_part[PART_ERR].ch_partial;
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001082 vim_free(*cbp);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001083 partial_unref(*pp);
Bram Moolenaarb6b52522016-02-20 23:30:07 +01001084 if (opt->jo_err_cb != NULL && *opt->jo_err_cb != NUL)
1085 *cbp = vim_strsave(opt->jo_err_cb);
1086 else
1087 *cbp = NULL;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001088 *pp = opt->jo_err_partial;
1089 if (*pp != NULL)
1090 ++(*pp)->pt_refcount;
Bram Moolenaar0ba75a92016-02-19 23:21:26 +01001091 }
Bram Moolenaar4e221c92016-02-23 13:20:22 +01001092 if (opt->jo_set & JO_CLOSE_CALLBACK)
1093 {
1094 cbp = &channel->ch_close_cb;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001095 pp = &channel->ch_close_partial;
Bram Moolenaar4e221c92016-02-23 13:20:22 +01001096 vim_free(*cbp);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001097 partial_unref(*pp);
Bram Moolenaar4e221c92016-02-23 13:20:22 +01001098 if (opt->jo_close_cb != NULL && *opt->jo_close_cb != NUL)
1099 *cbp = vim_strsave(opt->jo_close_cb);
1100 else
1101 *cbp = NULL;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001102 *pp = opt->jo_err_partial;
1103 if (*pp != NULL)
1104 ++(*pp)->pt_refcount;
Bram Moolenaar4e221c92016-02-23 13:20:22 +01001105 }
Bram Moolenaar187db502016-02-27 14:44:26 +01001106
1107 if ((opt->jo_set & JO_OUT_IO) && opt->jo_io[PART_OUT] == JIO_BUFFER)
1108 {
Bram Moolenaarcc7f8be2016-02-29 22:55:56 +01001109 /* writing output to a buffer. Default mode is NL. */
1110 if (!(opt->jo_set & JO_OUT_MODE))
1111 channel->ch_part[PART_OUT].ch_mode = MODE_NL;
Bram Moolenaar29fd0382016-03-09 23:14:07 +01001112 if (opt->jo_set & JO_OUT_BUF)
1113 channel->ch_part[PART_OUT].ch_buffer =
1114 buflist_findnr(opt->jo_io_buf[PART_OUT]);
1115 else
1116 channel->ch_part[PART_OUT].ch_buffer =
Bram Moolenaar6ff02c92016-03-08 20:12:44 +01001117 find_buffer(opt->jo_io_name[PART_OUT], FALSE);
1118 ch_logs(channel, "writing out to buffer '%s'",
Bram Moolenaar187db502016-02-27 14:44:26 +01001119 (char *)channel->ch_part[PART_OUT].ch_buffer->b_ffname);
1120 }
Bram Moolenaar6ff02c92016-03-08 20:12:44 +01001121
1122 if ((opt->jo_set & JO_ERR_IO) && (opt->jo_io[PART_ERR] == JIO_BUFFER
1123 || (opt->jo_io[PART_ERR] == JIO_OUT && (opt->jo_set & JO_OUT_IO)
1124 && opt->jo_io[PART_OUT] == JIO_BUFFER)))
1125 {
1126 /* writing err to a buffer. Default mode is NL. */
1127 if (!(opt->jo_set & JO_ERR_MODE))
1128 channel->ch_part[PART_ERR].ch_mode = MODE_NL;
1129 if (opt->jo_io[PART_ERR] == JIO_OUT)
1130 channel->ch_part[PART_ERR].ch_buffer =
1131 channel->ch_part[PART_OUT].ch_buffer;
Bram Moolenaar29fd0382016-03-09 23:14:07 +01001132 else if (opt->jo_set & JO_ERR_BUF)
1133 channel->ch_part[PART_ERR].ch_buffer =
1134 buflist_findnr(opt->jo_io_buf[PART_ERR]);
Bram Moolenaar6ff02c92016-03-08 20:12:44 +01001135 else
1136 channel->ch_part[PART_ERR].ch_buffer =
1137 find_buffer(opt->jo_io_name[PART_ERR], TRUE);
1138 ch_logs(channel, "writing err to buffer '%s'",
1139 (char *)channel->ch_part[PART_ERR].ch_buffer->b_ffname);
1140 }
Bram Moolenaar910b8aa2016-02-16 21:03:07 +01001141}
1142
1143/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001144 * Set the callback for "channel"/"part" for the response with "id".
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001145 */
1146 void
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001147channel_set_req_callback(
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001148 channel_T *channel,
1149 int part,
1150 char_u *callback,
1151 partial_T *partial,
1152 int id)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001153{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001154 cbq_T *head = &channel->ch_part[part].ch_cb_head;
Bram Moolenaara07fec92016-02-05 21:04:08 +01001155 cbq_T *item = (cbq_T *)alloc((int)sizeof(cbq_T));
1156
1157 if (item != NULL)
1158 {
Bram Moolenaar77073442016-02-13 23:23:53 +01001159 item->cq_callback = vim_strsave(callback);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001160 item->cq_partial = partial;
1161 if (partial != NULL)
1162 ++partial->pt_refcount;
Bram Moolenaar77073442016-02-13 23:23:53 +01001163 item->cq_seq_nr = id;
1164 item->cq_prev = head->cq_prev;
1165 head->cq_prev = item;
1166 item->cq_next = NULL;
1167 if (item->cq_prev == NULL)
1168 head->cq_next = item;
1169 else
1170 item->cq_prev->cq_next = item;
Bram Moolenaara07fec92016-02-05 21:04:08 +01001171 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001172}
1173
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001174 static void
1175write_buf_line(buf_T *buf, linenr_T lnum, channel_T *channel)
1176{
1177 char_u *line = ml_get_buf(buf, lnum, FALSE);
Bram Moolenaar367aabd2016-03-08 17:13:06 +01001178 int len = (int)STRLEN(line);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001179 char_u *p;
1180
1181 /* TODO: check if channel can be written to, do not block on write */
1182 if ((p = alloc(len + 2)) == NULL)
1183 return;
1184 STRCPY(p, line);
1185 p[len] = NL;
1186 p[len + 1] = NUL;
1187 channel_send(channel, PART_IN, p, "write_buf_line()");
1188 vim_free(p);
1189}
1190
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001191/*
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001192 * Write any lines to the input channel.
Bram Moolenaar014069a2016-03-03 22:51:40 +01001193 */
1194 void
1195channel_write_in(channel_T *channel)
1196{
1197 chanpart_T *in_part = &channel->ch_part[PART_IN];
1198 linenr_T lnum;
1199 buf_T *buf = in_part->ch_buffer;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001200 int written = 0;
Bram Moolenaar014069a2016-03-03 22:51:40 +01001201
1202 if (buf == NULL)
1203 return;
1204 if (!buf_valid(buf) || buf->b_ml.ml_mfp == NULL)
1205 {
1206 /* buffer was wiped out or unloaded */
1207 in_part->ch_buffer = NULL;
1208 return;
1209 }
1210 if (in_part->ch_fd == INVALID_FD)
1211 /* pipe was closed */
1212 return;
1213
1214 for (lnum = in_part->ch_buf_top; lnum <= in_part->ch_buf_bot
1215 && lnum <= buf->b_ml.ml_line_count; ++lnum)
1216 {
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001217 write_buf_line(buf, lnum, channel);
1218 ++written;
Bram Moolenaar014069a2016-03-03 22:51:40 +01001219 }
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001220
1221 if (written == 1)
1222 ch_logn(channel, "written line %d to channel", (int)lnum - 1);
1223 else if (written > 1)
1224 ch_logn(channel, "written %d lines to channel", written);
1225
Bram Moolenaar014069a2016-03-03 22:51:40 +01001226 in_part->ch_buf_top = lnum;
1227}
1228
1229/*
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001230 * Write appended lines above the last one in "buf" to the channel.
1231 */
1232 void
1233channel_write_new_lines(buf_T *buf)
1234{
1235 channel_T *channel;
1236 int found_one = FALSE;
1237
1238 /* There could be more than one channel for the buffer, loop over all of
1239 * them. */
1240 for (channel = first_channel; channel != NULL; channel = channel->ch_next)
1241 {
1242 chanpart_T *in_part = &channel->ch_part[PART_IN];
1243 linenr_T lnum;
1244 int written = 0;
1245
1246 if (in_part->ch_buffer == buf)
1247 {
1248 if (in_part->ch_fd == INVALID_FD)
1249 /* pipe was closed */
1250 continue;
1251 found_one = TRUE;
1252 for (lnum = in_part->ch_buf_bot; lnum < buf->b_ml.ml_line_count;
1253 ++lnum)
1254 {
1255 write_buf_line(buf, lnum, channel);
1256 ++written;
1257 }
1258
1259 if (written == 1)
1260 ch_logn(channel, "written line %d to channel", (int)lnum - 1);
1261 else if (written > 1)
1262 ch_logn(channel, "written %d lines to channel", written);
1263
1264 in_part->ch_buf_bot = lnum;
1265 }
1266 }
1267 if (!found_one)
1268 buf->b_write_to_channel = FALSE;
1269}
1270
1271/*
Bram Moolenaar77073442016-02-13 23:23:53 +01001272 * Invoke the "callback" on channel "channel".
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001273 */
1274 static void
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001275invoke_callback(channel_T *channel, char_u *callback, partial_T *partial,
1276 typval_T *argv)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001277{
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001278 typval_T rettv;
1279 int dummy;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001280
Bram Moolenaar77073442016-02-13 23:23:53 +01001281 argv[0].v_type = VAR_CHANNEL;
1282 argv[0].vval.v_channel = channel;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001283
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001284 call_func(callback, (int)STRLEN(callback),
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001285 &rettv, 2, argv, 0L, 0L, &dummy, TRUE, partial, NULL);
Bram Moolenaaree1cffc2016-02-21 19:14:41 +01001286 clear_tv(&rettv);
1287
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001288 /* If an echo command was used the cursor needs to be put back where
Bram Moolenaar18b5d6d2016-02-28 19:30:24 +01001289 * it belongs. If highlighting was changed a redraw is needed. */
1290 update_screen(0);
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001291 setcursor();
1292 cursor_on();
1293 out_flush();
Bram Moolenaar18b5d6d2016-02-28 19:30:24 +01001294#ifdef FEAT_GUI
Bram Moolenaara96909c2016-03-05 22:19:41 +01001295 if (gui.in_use)
1296 {
1297 gui_update_cursor(TRUE, FALSE);
1298 gui_mch_flush();
1299 }
Bram Moolenaar18b5d6d2016-02-28 19:30:24 +01001300#endif
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001301}
1302
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001303/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001304 * Return the first buffer from channel "channel"/"part" and remove it.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001305 * The caller must free it.
1306 * Returns NULL if there is nothing.
1307 */
1308 char_u *
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001309channel_get(channel_T *channel, int part)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001310{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001311 readq_T *head = &channel->ch_part[part].ch_head;
Bram Moolenaar77073442016-02-13 23:23:53 +01001312 readq_T *node = head->rq_next;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001313 char_u *p;
1314
Bram Moolenaar77073442016-02-13 23:23:53 +01001315 if (node == NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001316 return NULL;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001317 /* dispose of the node but keep the buffer */
Bram Moolenaar77073442016-02-13 23:23:53 +01001318 p = node->rq_buffer;
1319 head->rq_next = node->rq_next;
1320 if (node->rq_next == NULL)
1321 head->rq_prev = NULL;
1322 else
1323 node->rq_next->rq_prev = NULL;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001324 vim_free(node);
1325 return p;
1326}
1327
1328/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001329 * Returns the whole buffer contents concatenated for "channel"/"part".
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001330 */
1331 static char_u *
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001332channel_get_all(channel_T *channel, int part)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001333{
1334 /* Concatenate everything into one buffer.
1335 * TODO: avoid multiple allocations. */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001336 while (channel_collapse(channel, part) == OK)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001337 ;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001338 return channel_get(channel, part);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001339}
1340
1341/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001342 * Collapses the first and second buffer for "channel"/"part".
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001343 * Returns FAIL if that is not possible.
1344 */
1345 int
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001346channel_collapse(channel_T *channel, int part)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001347{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001348 readq_T *head = &channel->ch_part[part].ch_head;
Bram Moolenaar77073442016-02-13 23:23:53 +01001349 readq_T *node = head->rq_next;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001350 char_u *p;
1351
Bram Moolenaar77073442016-02-13 23:23:53 +01001352 if (node == NULL || node->rq_next == NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001353 return FAIL;
1354
Bram Moolenaar77073442016-02-13 23:23:53 +01001355 p = alloc((unsigned)(STRLEN(node->rq_buffer)
1356 + STRLEN(node->rq_next->rq_buffer) + 1));
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001357 if (p == NULL)
1358 return FAIL; /* out of memory */
Bram Moolenaar77073442016-02-13 23:23:53 +01001359 STRCPY(p, node->rq_buffer);
1360 STRCAT(p, node->rq_next->rq_buffer);
1361 vim_free(node->rq_next->rq_buffer);
1362 node->rq_next->rq_buffer = p;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001363
Bram Moolenaar77073442016-02-13 23:23:53 +01001364 /* dispose of the node and its buffer */
1365 head->rq_next = node->rq_next;
1366 head->rq_next->rq_prev = NULL;
1367 vim_free(node->rq_buffer);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001368 vim_free(node);
1369 return OK;
1370}
1371
1372/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001373 * Store "buf[len]" on "channel"/"part".
1374 * Returns OK or FAIL.
1375 */
1376 static int
1377channel_save(channel_T *channel, int part, char_u *buf, int len)
1378{
1379 readq_T *node;
1380 readq_T *head = &channel->ch_part[part].ch_head;
1381 char_u *p;
1382 int i;
1383
1384 node = (readq_T *)alloc(sizeof(readq_T));
1385 if (node == NULL)
1386 return FAIL; /* out of memory */
1387 node->rq_buffer = alloc(len + 1);
1388 if (node->rq_buffer == NULL)
1389 {
1390 vim_free(node);
1391 return FAIL; /* out of memory */
1392 }
1393
1394 if (channel->ch_part[part].ch_mode == MODE_NL)
1395 {
1396 /* Drop any CR before a NL. */
1397 p = node->rq_buffer;
1398 for (i = 0; i < len; ++i)
1399 if (buf[i] != CAR || i + 1 >= len || buf[i + 1] != NL)
1400 *p++ = buf[i];
1401 *p = NUL;
1402 }
1403 else
1404 {
1405 mch_memmove(node->rq_buffer, buf, len);
1406 node->rq_buffer[len] = NUL;
1407 }
1408
1409 /* append node to the tail of the queue */
1410 node->rq_next = NULL;
1411 node->rq_prev = head->rq_prev;
1412 if (head->rq_prev == NULL)
1413 head->rq_next = node;
1414 else
1415 head->rq_prev->rq_next = node;
1416 head->rq_prev = node;
1417
1418 if (log_fd != NULL)
1419 {
1420 ch_log_lead("RECV ", channel);
1421 fprintf(log_fd, "'");
1422 if (fwrite(buf, len, 1, log_fd) != 1)
1423 return FAIL;
1424 fprintf(log_fd, "'\n");
1425 }
1426 return OK;
1427}
1428
1429/*
1430 * Use the read buffer of "channel"/"part" and parse a JSON messages that is
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001431 * complete. The messages are added to the queue.
Bram Moolenaard7ece102016-02-02 23:23:02 +01001432 * Return TRUE if there is more to read.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001433 */
Bram Moolenaard7ece102016-02-02 23:23:02 +01001434 static int
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001435channel_parse_json(channel_T *channel, int part)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001436{
1437 js_read_T reader;
1438 typval_T listtv;
1439 jsonq_T *item;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001440 jsonq_T *head = &channel->ch_part[part].ch_json_head;
Bram Moolenaard7ece102016-02-02 23:23:02 +01001441 int ret;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001442
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001443 if (channel_peek(channel, part) == NULL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01001444 return FALSE;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001445
1446 /* TODO: make reader work properly */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001447 /* reader.js_buf = channel_peek(channel, part); */
1448 reader.js_buf = channel_get_all(channel, part);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001449 reader.js_used = 0;
Bram Moolenaar56ead342016-02-02 18:20:08 +01001450 reader.js_fill = NULL;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001451 /* reader.js_fill = channel_fill; */
Bram Moolenaar77073442016-02-13 23:23:53 +01001452 reader.js_cookie = channel;
Bram Moolenaar595e64e2016-02-07 19:19:53 +01001453 ret = json_decode(&reader, &listtv,
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001454 channel->ch_part[part].ch_mode == MODE_JS ? JSON_JS : 0);
Bram Moolenaard7ece102016-02-02 23:23:02 +01001455 if (ret == OK)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001456 {
Bram Moolenaar6076fe12016-02-05 22:49:56 +01001457 /* Only accept the response when it is a list with at least two
1458 * items. */
1459 if (listtv.v_type != VAR_LIST || listtv.vval.v_list->lv_len < 2)
Bram Moolenaard7ece102016-02-02 23:23:02 +01001460 {
1461 /* TODO: give error */
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001462 clear_tv(&listtv);
Bram Moolenaard7ece102016-02-02 23:23:02 +01001463 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001464 else
1465 {
Bram Moolenaard7ece102016-02-02 23:23:02 +01001466 item = (jsonq_T *)alloc((unsigned)sizeof(jsonq_T));
1467 if (item == NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001468 clear_tv(&listtv);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001469 else
1470 {
Bram Moolenaar77073442016-02-13 23:23:53 +01001471 item->jq_value = alloc_tv();
1472 if (item->jq_value == NULL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01001473 {
1474 vim_free(item);
1475 clear_tv(&listtv);
1476 }
1477 else
1478 {
Bram Moolenaar77073442016-02-13 23:23:53 +01001479 *item->jq_value = listtv;
1480 item->jq_prev = head->jq_prev;
1481 head->jq_prev = item;
1482 item->jq_next = NULL;
1483 if (item->jq_prev == NULL)
1484 head->jq_next = item;
1485 else
1486 item->jq_prev->jq_next = item;
Bram Moolenaard7ece102016-02-02 23:23:02 +01001487 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001488 }
1489 }
1490 }
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01001491
1492 /* Put the unread part back into the channel.
1493 * TODO: insert in front */
1494 if (reader.js_buf[reader.js_used] != NUL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01001495 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001496 channel_save(channel, part, reader.js_buf + reader.js_used,
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01001497 (int)(reader.js_end - reader.js_buf) - reader.js_used);
Bram Moolenaard7ece102016-02-02 23:23:02 +01001498 ret = TRUE;
1499 }
1500 else
1501 ret = FALSE;
1502
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01001503 vim_free(reader.js_buf);
Bram Moolenaard7ece102016-02-02 23:23:02 +01001504 return ret;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001505}
1506
1507/*
Bram Moolenaard46ae142016-02-16 13:33:52 +01001508 * Remove "node" from the queue that it is in. Does not free it.
Bram Moolenaara07fec92016-02-05 21:04:08 +01001509 */
1510 static void
Bram Moolenaar77073442016-02-13 23:23:53 +01001511remove_cb_node(cbq_T *head, cbq_T *node)
Bram Moolenaara07fec92016-02-05 21:04:08 +01001512{
Bram Moolenaar77073442016-02-13 23:23:53 +01001513 if (node->cq_prev == NULL)
1514 head->cq_next = node->cq_next;
1515 else
1516 node->cq_prev->cq_next = node->cq_next;
1517 if (node->cq_next == NULL)
1518 head->cq_prev = node->cq_prev;
1519 else
1520 node->cq_next->cq_prev = node->cq_prev;
Bram Moolenaara07fec92016-02-05 21:04:08 +01001521}
1522
1523/*
1524 * Remove "node" from the queue that it is in and free it.
Bram Moolenaar77073442016-02-13 23:23:53 +01001525 * Caller should have freed or used node->jq_value.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001526 */
1527 static void
Bram Moolenaar77073442016-02-13 23:23:53 +01001528remove_json_node(jsonq_T *head, jsonq_T *node)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001529{
Bram Moolenaar77073442016-02-13 23:23:53 +01001530 if (node->jq_prev == NULL)
1531 head->jq_next = node->jq_next;
1532 else
1533 node->jq_prev->jq_next = node->jq_next;
1534 if (node->jq_next == NULL)
1535 head->jq_prev = node->jq_prev;
1536 else
1537 node->jq_next->jq_prev = node->jq_prev;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001538 vim_free(node);
1539}
1540
1541/*
Bram Moolenaar77073442016-02-13 23:23:53 +01001542 * Get a message from the JSON queue for channel "channel".
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001543 * When "id" is positive it must match the first number in the list.
Bram Moolenaare56bf152016-02-08 23:23:42 +01001544 * When "id" is zero or negative jut get the first message. But not the one
1545 * with id ch_block_id.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001546 * Return OK when found and return the value in "rettv".
1547 * Return FAIL otherwise.
1548 */
1549 static int
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001550channel_get_json(channel_T *channel, int part, int id, typval_T **rettv)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001551{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001552 jsonq_T *head = &channel->ch_part[part].ch_json_head;
Bram Moolenaar77073442016-02-13 23:23:53 +01001553 jsonq_T *item = head->jq_next;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001554
Bram Moolenaar77073442016-02-13 23:23:53 +01001555 while (item != NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001556 {
Bram Moolenaar77073442016-02-13 23:23:53 +01001557 list_T *l = item->jq_value->vval.v_list;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001558 typval_T *tv = &l->lv_first->li_tv;
1559
1560 if ((id > 0 && tv->v_type == VAR_NUMBER && tv->vval.v_number == id)
Bram Moolenaare56bf152016-02-08 23:23:42 +01001561 || (id <= 0 && (tv->v_type != VAR_NUMBER
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001562 || tv->vval.v_number == 0
1563 || tv->vval.v_number != channel->ch_part[part].ch_block_id)))
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001564 {
Bram Moolenaar77073442016-02-13 23:23:53 +01001565 *rettv = item->jq_value;
1566 remove_json_node(head, item);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001567 return OK;
1568 }
Bram Moolenaar77073442016-02-13 23:23:53 +01001569 item = item->jq_next;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001570 }
1571 return FAIL;
1572}
1573
Bram Moolenaarece61b02016-02-20 21:39:05 +01001574#define CH_JSON_MAX_ARGS 4
1575
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001576/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001577 * Execute a command received over "channel"/"part"
Bram Moolenaarece61b02016-02-20 21:39:05 +01001578 * "argv[0]" is the command string.
1579 * "argv[1]" etc. have further arguments, type is VAR_UNKNOWN if missing.
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001580 */
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001581 static void
Bram Moolenaarece61b02016-02-20 21:39:05 +01001582channel_exe_cmd(channel_T *channel, int part, typval_T *argv)
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001583{
Bram Moolenaarece61b02016-02-20 21:39:05 +01001584 char_u *cmd = argv[0].vval.v_string;
1585 char_u *arg;
1586 int options = channel->ch_part[part].ch_mode == MODE_JS ? JSON_JS : 0;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001587
Bram Moolenaarece61b02016-02-20 21:39:05 +01001588 if (argv[1].v_type != VAR_STRING)
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001589 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01001590 ch_error(channel, "received command with non-string argument");
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001591 if (p_verbose > 2)
Bram Moolenaarece61b02016-02-20 21:39:05 +01001592 EMSG("E903: received command with non-string argument");
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001593 return;
1594 }
Bram Moolenaarece61b02016-02-20 21:39:05 +01001595 arg = argv[1].vval.v_string;
Bram Moolenaar14ad6112016-02-01 21:47:13 +01001596 if (arg == NULL)
1597 arg = (char_u *)"";
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001598
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001599 if (STRCMP(cmd, "ex") == 0)
1600 {
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001601 do_cmdline_cmd(arg);
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001602 }
1603 else if (STRCMP(cmd, "normal") == 0)
1604 {
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001605 exarg_T ea;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001606
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001607 ea.arg = arg;
1608 ea.addr_count = 0;
1609 ea.forceit = TRUE; /* no mapping */
1610 ex_normal(&ea);
1611 }
1612 else if (STRCMP(cmd, "redraw") == 0)
1613 {
1614 exarg_T ea;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001615
Bram Moolenaar14ad6112016-02-01 21:47:13 +01001616 ea.forceit = *arg != NUL;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001617 ex_redraw(&ea);
1618 showruler(FALSE);
1619 setcursor();
1620 out_flush();
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001621#ifdef FEAT_GUI
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001622 if (gui.in_use)
1623 {
1624 gui_update_cursor(FALSE, FALSE);
1625 gui_mch_flush();
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001626 }
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001627#endif
1628 }
Bram Moolenaarece61b02016-02-20 21:39:05 +01001629 else if (STRCMP(cmd, "expr") == 0 || STRCMP(cmd, "call") == 0)
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001630 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01001631 int is_call = cmd[0] == 'c';
1632 int id_idx = is_call ? 3 : 2;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001633
Bram Moolenaarece61b02016-02-20 21:39:05 +01001634 if (argv[id_idx].v_type != VAR_UNKNOWN
1635 && argv[id_idx].v_type != VAR_NUMBER)
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001636 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01001637 ch_error(channel, "last argument for expr/call must be a number");
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001638 if (p_verbose > 2)
Bram Moolenaarece61b02016-02-20 21:39:05 +01001639 EMSG("E904: last argument for expr/call must be a number");
1640 }
1641 else if (is_call && argv[2].v_type != VAR_LIST)
1642 {
1643 ch_error(channel, "third argument for call must be a list");
1644 if (p_verbose > 2)
1645 EMSG("E904: third argument for call must be a list");
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001646 }
1647 else
1648 {
Bram Moolenaarfcb1e3d2016-02-03 21:32:46 +01001649 typval_T *tv;
Bram Moolenaarece61b02016-02-20 21:39:05 +01001650 typval_T res_tv;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001651 typval_T err_tv;
Bram Moolenaar55fab432016-02-07 16:53:13 +01001652 char_u *json = NULL;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001653
Bram Moolenaarfcb1e3d2016-02-03 21:32:46 +01001654 /* Don't pollute the display with errors. */
1655 ++emsg_skip;
Bram Moolenaarece61b02016-02-20 21:39:05 +01001656 if (!is_call)
1657 tv = eval_expr(arg, NULL);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001658 else if (func_call(arg, &argv[2], NULL, NULL, &res_tv) == OK)
Bram Moolenaarece61b02016-02-20 21:39:05 +01001659 tv = &res_tv;
1660 else
1661 tv = NULL;
1662
1663 if (argv[id_idx].v_type == VAR_NUMBER)
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001664 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01001665 int id = argv[id_idx].vval.v_number;
1666
Bram Moolenaar55fab432016-02-07 16:53:13 +01001667 if (tv != NULL)
Bram Moolenaarece61b02016-02-20 21:39:05 +01001668 json = json_encode_nr_expr(id, tv, options);
Bram Moolenaar55fab432016-02-07 16:53:13 +01001669 if (tv == NULL || (json != NULL && *json == NUL))
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001670 {
Bram Moolenaar55fab432016-02-07 16:53:13 +01001671 /* If evaluation failed or the result can't be encoded
1672 * then return the string "ERROR". */
Bram Moolenaar77073442016-02-13 23:23:53 +01001673 vim_free(json);
1674 free_tv(tv);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001675 err_tv.v_type = VAR_STRING;
1676 err_tv.vval.v_string = (char_u *)"ERROR";
1677 tv = &err_tv;
Bram Moolenaarece61b02016-02-20 21:39:05 +01001678 json = json_encode_nr_expr(id, tv, options);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001679 }
Bram Moolenaar55fab432016-02-07 16:53:13 +01001680 if (json != NULL)
1681 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01001682 channel_send(channel,
1683 part == PART_SOCK ? PART_SOCK : PART_IN,
1684 json, (char *)cmd);
Bram Moolenaar55fab432016-02-07 16:53:13 +01001685 vim_free(json);
1686 }
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001687 }
Bram Moolenaar55fab432016-02-07 16:53:13 +01001688 --emsg_skip;
Bram Moolenaarece61b02016-02-20 21:39:05 +01001689 if (tv == &res_tv)
1690 clear_tv(tv);
1691 else if (tv != &err_tv)
Bram Moolenaarfcb1e3d2016-02-03 21:32:46 +01001692 free_tv(tv);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001693 }
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001694 }
1695 else if (p_verbose > 2)
Bram Moolenaarece61b02016-02-20 21:39:05 +01001696 {
1697 ch_errors(channel, "Receved unknown command: %s", (char *)cmd);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001698 EMSG2("E905: received unknown command: %s", cmd);
Bram Moolenaarece61b02016-02-20 21:39:05 +01001699 }
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001700}
1701
Bram Moolenaard6547fc2016-03-03 19:35:02 +01001702 static void
1703invoke_one_time_callback(
1704 channel_T *channel,
1705 cbq_T *cbhead,
1706 cbq_T *item,
1707 typval_T *argv)
1708{
1709 ch_logs(channel, "Invoking one-time callback %s",
1710 (char *)item->cq_callback);
1711 /* Remove the item from the list first, if the callback
1712 * invokes ch_close() the list will be cleared. */
1713 remove_cb_node(cbhead, item);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001714 invoke_callback(channel, item->cq_callback, item->cq_partial, argv);
Bram Moolenaard6547fc2016-03-03 19:35:02 +01001715 vim_free(item->cq_callback);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001716 partial_unref(item->cq_partial);
Bram Moolenaard6547fc2016-03-03 19:35:02 +01001717 vim_free(item);
1718}
1719
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001720 static void
1721append_to_buffer(buf_T *buffer, char_u *msg, channel_T *channel)
1722{
1723 buf_T *save_curbuf = curbuf;
1724 linenr_T lnum = buffer->b_ml.ml_line_count;
1725 int save_write_to = buffer->b_write_to_channel;
1726
1727 /* If the buffer is also used as input insert above the last
1728 * line. Don't write these lines. */
1729 if (save_write_to)
1730 {
1731 --lnum;
1732 buffer->b_write_to_channel = FALSE;
1733 }
1734
1735 /* Append to the buffer */
1736 ch_logn(channel, "appending line %d to buffer", (int)lnum + 1);
1737
1738 curbuf = buffer;
1739 u_sync(TRUE);
1740 /* ignore undo failure, undo is not very useful here */
1741 ignored = u_save(lnum, lnum + 1);
1742
1743 ml_append(lnum, msg, 0, FALSE);
1744 appended_lines_mark(lnum, 1L);
1745 curbuf = save_curbuf;
1746
1747 if (buffer->b_nwindows > 0)
1748 {
1749 win_T *wp;
1750 win_T *save_curwin;
1751
1752 FOR_ALL_WINDOWS(wp)
1753 {
1754 if (wp->w_buffer == buffer
1755 && (save_write_to
1756 ? wp->w_cursor.lnum == lnum + 1
1757 : (wp->w_cursor.lnum == lnum
1758 && wp->w_cursor.col == 0)))
1759 {
1760 ++wp->w_cursor.lnum;
1761 save_curwin = curwin;
1762 curwin = wp;
1763 curbuf = curwin->w_buffer;
1764 scroll_cursor_bot(0, FALSE);
1765 curwin = save_curwin;
1766 curbuf = curwin->w_buffer;
1767 }
1768 }
1769 redraw_buf_later(buffer, VALID);
1770 channel_need_redraw = TRUE;
1771 }
1772
1773 if (save_write_to)
1774 {
1775 channel_T *ch;
1776
1777 /* Find channels reading from this buffer and adjust their
1778 * next-to-read line number. */
1779 buffer->b_write_to_channel = TRUE;
1780 for (ch = first_channel; ch != NULL; ch = ch->ch_next)
1781 {
1782 chanpart_T *in_part = &ch->ch_part[PART_IN];
1783
1784 if (in_part->ch_buffer == buffer)
1785 in_part->ch_buf_bot = buffer->b_ml.ml_line_count;
1786 }
1787 }
1788}
1789
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001790/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001791 * Invoke a callback for "channel"/"part" if needed.
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01001792 * Return TRUE when a message was handled, there might be another one.
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001793 */
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01001794 static int
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001795may_invoke_callback(channel_T *channel, int part)
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001796{
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001797 char_u *msg = NULL;
1798 typval_T *listtv = NULL;
Bram Moolenaarece61b02016-02-20 21:39:05 +01001799 typval_T argv[CH_JSON_MAX_ARGS];
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001800 int seq_nr = -1;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001801 ch_mode_T ch_mode = channel->ch_part[part].ch_mode;
Bram Moolenaard6547fc2016-03-03 19:35:02 +01001802 cbq_T *cbhead = &channel->ch_part[part].ch_cb_head;
Bram Moolenaar5983ad02016-03-05 20:54:36 +01001803 cbq_T *cbitem;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001804 char_u *callback = NULL;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001805 partial_T *partial = NULL;
Bram Moolenaar187db502016-02-27 14:44:26 +01001806 buf_T *buffer = NULL;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001807
Bram Moolenaar4e221c92016-02-23 13:20:22 +01001808 if (channel->ch_nb_close_cb != NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001809 /* this channel is handled elsewhere (netbeans) */
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01001810 return FALSE;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001811
Bram Moolenaar5983ad02016-03-05 20:54:36 +01001812 /* Use a message-specific callback, part callback or channel callback */
1813 for (cbitem = cbhead->cq_next; cbitem != NULL; cbitem = cbitem->cq_next)
1814 if (cbitem->cq_seq_nr == 0)
1815 break;
Bram Moolenaard6547fc2016-03-03 19:35:02 +01001816 if (cbitem != NULL)
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001817 {
Bram Moolenaard6547fc2016-03-03 19:35:02 +01001818 callback = cbitem->cq_callback;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001819 partial = cbitem->cq_partial;
1820 }
Bram Moolenaard6547fc2016-03-03 19:35:02 +01001821 else if (channel->ch_part[part].ch_callback != NULL)
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001822 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001823 callback = channel->ch_part[part].ch_callback;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001824 partial = channel->ch_part[part].ch_partial;
1825 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001826 else
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001827 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001828 callback = channel->ch_callback;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001829 partial = channel->ch_partial;
1830 }
Bram Moolenaarc7f0ebc2016-02-27 21:10:09 +01001831
Bram Moolenaar187db502016-02-27 14:44:26 +01001832 buffer = channel->ch_part[part].ch_buffer;
Bram Moolenaarc7f0ebc2016-02-27 21:10:09 +01001833 if (buffer != NULL && !buf_valid(buffer))
1834 {
1835 /* buffer was wiped out */
1836 channel->ch_part[part].ch_buffer = NULL;
1837 buffer = NULL;
1838 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001839
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01001840 if (ch_mode == MODE_JSON || ch_mode == MODE_JS)
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001841 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01001842 listitem_T *item;
1843 int argc = 0;
1844
Bram Moolenaard7ece102016-02-02 23:23:02 +01001845 /* Get any json message in the queue. */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001846 if (channel_get_json(channel, part, -1, &listtv) == FAIL)
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001847 {
Bram Moolenaard7ece102016-02-02 23:23:02 +01001848 /* Parse readahead, return when there is still no message. */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001849 channel_parse_json(channel, part);
1850 if (channel_get_json(channel, part, -1, &listtv) == FAIL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01001851 return FALSE;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001852 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001853
Bram Moolenaarece61b02016-02-20 21:39:05 +01001854 for (item = listtv->vval.v_list->lv_first;
1855 item != NULL && argc < CH_JSON_MAX_ARGS;
1856 item = item->li_next)
1857 argv[argc++] = item->li_tv;
1858 while (argc < CH_JSON_MAX_ARGS)
1859 argv[argc++].v_type = VAR_UNKNOWN;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001860
Bram Moolenaarece61b02016-02-20 21:39:05 +01001861 if (argv[0].v_type == VAR_STRING)
1862 {
1863 char_u *cmd = argv[0].vval.v_string;
1864
1865 /* ["cmd", arg] or ["cmd", arg, arg] or ["cmd", arg, arg, arg] */
Bram Moolenaar77073442016-02-13 23:23:53 +01001866 ch_logs(channel, "Executing %s command", (char *)cmd);
Bram Moolenaarece61b02016-02-20 21:39:05 +01001867 channel_exe_cmd(channel, part, argv);
Bram Moolenaar77073442016-02-13 23:23:53 +01001868 free_tv(listtv);
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01001869 return TRUE;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001870 }
1871
Bram Moolenaarece61b02016-02-20 21:39:05 +01001872 if (argv[0].v_type != VAR_NUMBER)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001873 {
Bram Moolenaar77073442016-02-13 23:23:53 +01001874 ch_error(channel,
Bram Moolenaar81661fb2016-02-18 22:23:34 +01001875 "Dropping message with invalid sequence number type");
Bram Moolenaar77073442016-02-13 23:23:53 +01001876 free_tv(listtv);
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01001877 return FALSE;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001878 }
Bram Moolenaarece61b02016-02-20 21:39:05 +01001879 seq_nr = argv[0].vval.v_number;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001880 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001881 else if (channel_peek(channel, part) == NULL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01001882 {
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01001883 /* nothing to read on RAW or NL channel */
Bram Moolenaard7ece102016-02-02 23:23:02 +01001884 return FALSE;
1885 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001886 else
1887 {
Bram Moolenaar187db502016-02-27 14:44:26 +01001888 /* If there is no callback or buffer drop the message. */
1889 if (callback == NULL && buffer == NULL)
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01001890 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001891 while ((msg = channel_get(channel, part)) != NULL)
Bram Moolenaard6051b52016-02-28 15:49:03 +01001892 {
1893 ch_logs(channel, "Dropping message '%s'", (char *)msg);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01001894 vim_free(msg);
Bram Moolenaard6051b52016-02-28 15:49:03 +01001895 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001896 return FALSE;
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01001897 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001898
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01001899 if (ch_mode == MODE_NL)
1900 {
1901 char_u *nl;
1902 char_u *buf;
1903
1904 /* See if we have a message ending in NL in the first buffer. If
1905 * not try to concatenate the first and the second buffer. */
1906 while (TRUE)
1907 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001908 buf = channel_peek(channel, part);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01001909 nl = vim_strchr(buf, NL);
1910 if (nl != NULL)
1911 break;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001912 if (channel_collapse(channel, part) == FAIL)
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01001913 return FALSE; /* incomplete message */
1914 }
1915 if (nl[1] == NUL)
Bram Moolenaar187db502016-02-27 14:44:26 +01001916 {
1917 /* get the whole buffer, drop the NL */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001918 msg = channel_get(channel, part);
Bram Moolenaar187db502016-02-27 14:44:26 +01001919 *nl = NUL;
1920 }
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01001921 else
1922 {
1923 /* Copy the message into allocated memory and remove it from
1924 * the buffer. */
1925 msg = vim_strnsave(buf, (int)(nl - buf));
1926 mch_memmove(buf, nl + 1, STRLEN(nl + 1) + 1);
1927 }
1928 }
1929 else
1930 /* For a raw channel we don't know where the message ends, just
1931 * get everything we have. */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001932 msg = channel_get_all(channel, part);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01001933
Bram Moolenaarbf73b912016-03-02 21:16:59 +01001934 if (msg == NULL)
1935 return FALSE; /* out of memory (and avoids Coverity warning) */
1936
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001937 argv[1].v_type = VAR_STRING;
1938 argv[1].vval.v_string = msg;
1939 }
1940
Bram Moolenaara07fec92016-02-05 21:04:08 +01001941 if (seq_nr > 0)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001942 {
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001943 int done = FALSE;
Bram Moolenaara07fec92016-02-05 21:04:08 +01001944
1945 /* invoke the one-time callback with the matching nr */
Bram Moolenaar5983ad02016-03-05 20:54:36 +01001946 for (cbitem = cbhead->cq_next; cbitem != NULL; cbitem = cbitem->cq_next)
Bram Moolenaard6547fc2016-03-03 19:35:02 +01001947 if (cbitem->cq_seq_nr == seq_nr)
Bram Moolenaara07fec92016-02-05 21:04:08 +01001948 {
Bram Moolenaard6547fc2016-03-03 19:35:02 +01001949 invoke_one_time_callback(channel, cbhead, cbitem, argv);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001950 done = TRUE;
Bram Moolenaara07fec92016-02-05 21:04:08 +01001951 break;
1952 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001953 if (!done)
Bram Moolenaard6051b52016-02-28 15:49:03 +01001954 ch_logn(channel, "Dropping message %d without callback", seq_nr);
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001955 }
Bram Moolenaar187db502016-02-27 14:44:26 +01001956 else if (callback != NULL || buffer != NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001957 {
Bram Moolenaar187db502016-02-27 14:44:26 +01001958 if (buffer != NULL)
1959 {
Bram Moolenaarcc7f8be2016-02-29 22:55:56 +01001960 if (msg == NULL)
1961 /* JSON or JS mode: re-encode the message. */
1962 msg = json_encode(listtv, ch_mode);
1963 if (msg != NULL)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001964 append_to_buffer(buffer, msg, channel);
Bram Moolenaar187db502016-02-27 14:44:26 +01001965 }
Bram Moolenaard6547fc2016-03-03 19:35:02 +01001966
Bram Moolenaar187db502016-02-27 14:44:26 +01001967 if (callback != NULL)
1968 {
Bram Moolenaard6547fc2016-03-03 19:35:02 +01001969 if (cbitem != NULL)
1970 invoke_one_time_callback(channel, cbhead, cbitem, argv);
1971 else
1972 {
1973 /* invoke the channel callback */
1974 ch_logs(channel, "Invoking channel callback %s",
1975 (char *)callback);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001976 invoke_callback(channel, callback, partial, argv);
Bram Moolenaard6547fc2016-03-03 19:35:02 +01001977 }
Bram Moolenaar187db502016-02-27 14:44:26 +01001978 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001979 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001980 else
Bram Moolenaar81661fb2016-02-18 22:23:34 +01001981 ch_log(channel, "Dropping message");
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001982
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001983 if (listtv != NULL)
Bram Moolenaar77073442016-02-13 23:23:53 +01001984 free_tv(listtv);
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001985 vim_free(msg);
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01001986
1987 return TRUE;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001988}
1989
1990/*
Bram Moolenaar77073442016-02-13 23:23:53 +01001991 * Return TRUE when channel "channel" is open for writing to.
1992 * Also returns FALSE or invalid "channel".
Bram Moolenaard04a0202016-01-26 23:30:18 +01001993 */
1994 int
Bram Moolenaar77073442016-02-13 23:23:53 +01001995channel_can_write_to(channel_T *channel)
Bram Moolenaard04a0202016-01-26 23:30:18 +01001996{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001997 return channel != NULL && (channel->CH_SOCK_FD != INVALID_FD
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01001998 || channel->CH_IN_FD != INVALID_FD);
Bram Moolenaard04a0202016-01-26 23:30:18 +01001999}
2000
2001/*
Bram Moolenaar77073442016-02-13 23:23:53 +01002002 * Return TRUE when channel "channel" is open for reading or writing.
2003 * Also returns FALSE for invalid "channel".
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002004 */
2005 int
Bram Moolenaar77073442016-02-13 23:23:53 +01002006channel_is_open(channel_T *channel)
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002007{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002008 return channel != NULL && (channel->CH_SOCK_FD != INVALID_FD
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002009 || channel->CH_IN_FD != INVALID_FD
2010 || channel->CH_OUT_FD != INVALID_FD
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01002011 || channel->CH_ERR_FD != INVALID_FD);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002012}
2013
2014/*
Bram Moolenaar77073442016-02-13 23:23:53 +01002015 * Return a string indicating the status of the channel.
2016 */
2017 char *
2018channel_status(channel_T *channel)
2019{
2020 if (channel == NULL)
2021 return "fail";
2022 if (channel_is_open(channel))
2023 return "open";
2024 return "closed";
2025}
2026
2027/*
2028 * Close channel "channel".
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +01002029 * Trigger the close callback if "invoke_close_cb" is TRUE.
Bram Moolenaar187db502016-02-27 14:44:26 +01002030 * Does not clear the buffers.
Bram Moolenaard04a0202016-01-26 23:30:18 +01002031 */
2032 void
Bram Moolenaar8b374212016-02-24 20:43:06 +01002033channel_close(channel_T *channel, int invoke_close_cb)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002034{
Bram Moolenaar81661fb2016-02-18 22:23:34 +01002035 ch_log(channel, "Closing channel");
Bram Moolenaard04a0202016-01-26 23:30:18 +01002036
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002037#ifdef FEAT_GUI
2038 channel_gui_unregister(channel);
2039#endif
2040
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002041 if (channel->CH_SOCK_FD != INVALID_FD)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002042 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002043 sock_close(channel->CH_SOCK_FD);
2044 channel->CH_SOCK_FD = INVALID_FD;
Bram Moolenaare0874f82016-01-24 20:36:41 +01002045 }
Bram Moolenaarde279892016-03-11 22:19:44 +01002046 may_close_part(&channel->CH_IN_FD);
2047 may_close_part(&channel->CH_OUT_FD);
2048 may_close_part(&channel->CH_ERR_FD);
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002049
Bram Moolenaar8b374212016-02-24 20:43:06 +01002050 if (invoke_close_cb && channel->ch_close_cb != NULL)
Bram Moolenaar4e221c92016-02-23 13:20:22 +01002051 {
2052 typval_T argv[1];
2053 typval_T rettv;
2054 int dummy;
2055
2056 /* invoke the close callback; increment the refcount to avoid it
2057 * being freed halfway */
Bram Moolenaard6051b52016-02-28 15:49:03 +01002058 ch_logs(channel, "Invoking close callback %s",
2059 (char *)channel->ch_close_cb);
Bram Moolenaar4e221c92016-02-23 13:20:22 +01002060 argv[0].v_type = VAR_CHANNEL;
2061 argv[0].vval.v_channel = channel;
2062 ++channel->ch_refcount;
2063 call_func(channel->ch_close_cb, (int)STRLEN(channel->ch_close_cb),
Bram Moolenaar1735bc92016-03-14 23:05:14 +01002064 &rettv, 1, argv, 0L, 0L, &dummy, TRUE,
2065 channel->ch_close_partial, NULL);
Bram Moolenaar4e221c92016-02-23 13:20:22 +01002066 clear_tv(&rettv);
2067 --channel->ch_refcount;
2068
2069 /* the callback is only called once */
2070 vim_free(channel->ch_close_cb);
2071 channel->ch_close_cb = NULL;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01002072 partial_unref(channel->ch_close_partial);
2073 channel->ch_close_partial = NULL;
Bram Moolenaar4e221c92016-02-23 13:20:22 +01002074 }
2075
2076 channel->ch_nb_close_cb = NULL;
Bram Moolenaare0874f82016-01-24 20:36:41 +01002077}
2078
Bram Moolenaard04a0202016-01-26 23:30:18 +01002079/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002080 * Return the first buffer from "channel"/"part" without removing it.
Bram Moolenaard04a0202016-01-26 23:30:18 +01002081 * Returns NULL if there is nothing.
2082 */
2083 char_u *
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002084channel_peek(channel_T *channel, int part)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002085{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002086 readq_T *head = &channel->ch_part[part].ch_head;
Bram Moolenaard04a0202016-01-26 23:30:18 +01002087
Bram Moolenaar77073442016-02-13 23:23:53 +01002088 if (head->rq_next == NULL)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002089 return NULL;
Bram Moolenaar77073442016-02-13 23:23:53 +01002090 return head->rq_next->rq_buffer;
Bram Moolenaard04a0202016-01-26 23:30:18 +01002091}
2092
2093/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002094 * Clear the read buffer on "channel"/"part".
Bram Moolenaard04a0202016-01-26 23:30:18 +01002095 */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002096 static void
2097channel_clear_one(channel_T *channel, int part)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002098{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002099 jsonq_T *json_head = &channel->ch_part[part].ch_json_head;
2100 cbq_T *cb_head = &channel->ch_part[part].ch_cb_head;
Bram Moolenaard04a0202016-01-26 23:30:18 +01002101
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002102 while (channel_peek(channel, part) != NULL)
2103 vim_free(channel_get(channel, part));
Bram Moolenaar77073442016-02-13 23:23:53 +01002104
2105 while (cb_head->cq_next != NULL)
Bram Moolenaard46ae142016-02-16 13:33:52 +01002106 {
2107 cbq_T *node = cb_head->cq_next;
2108
2109 remove_cb_node(cb_head, node);
2110 vim_free(node->cq_callback);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01002111 partial_unref(node->cq_partial);
Bram Moolenaard46ae142016-02-16 13:33:52 +01002112 vim_free(node);
2113 }
Bram Moolenaar77073442016-02-13 23:23:53 +01002114
2115 while (json_head->jq_next != NULL)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002116 {
Bram Moolenaar77073442016-02-13 23:23:53 +01002117 free_tv(json_head->jq_next->jq_value);
2118 remove_json_node(json_head, json_head->jq_next);
Bram Moolenaard04a0202016-01-26 23:30:18 +01002119 }
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01002120
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002121 vim_free(channel->ch_part[part].ch_callback);
2122 channel->ch_part[part].ch_callback = NULL;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01002123 partial_unref(channel->ch_part[part].ch_partial);
2124 channel->ch_part[part].ch_partial = NULL;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002125}
2126
2127/*
2128 * Clear all the read buffers on "channel".
2129 */
2130 void
2131channel_clear(channel_T *channel)
2132{
Bram Moolenaard6051b52016-02-28 15:49:03 +01002133 ch_log(channel, "Clearing channel");
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002134 channel_clear_one(channel, PART_SOCK);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002135 channel_clear_one(channel, PART_OUT);
2136 channel_clear_one(channel, PART_ERR);
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01002137 vim_free(channel->ch_callback);
2138 channel->ch_callback = NULL;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01002139 partial_unref(channel->ch_partial);
2140 channel->ch_partial = NULL;
Bram Moolenaar4e221c92016-02-23 13:20:22 +01002141 vim_free(channel->ch_close_cb);
2142 channel->ch_close_cb = NULL;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01002143 partial_unref(channel->ch_close_partial);
2144 channel->ch_close_partial = NULL;
Bram Moolenaard04a0202016-01-26 23:30:18 +01002145}
2146
Bram Moolenaar77073442016-02-13 23:23:53 +01002147#if defined(EXITFREE) || defined(PROTO)
2148 void
2149channel_free_all(void)
2150{
2151 channel_T *channel;
2152
Bram Moolenaard6051b52016-02-28 15:49:03 +01002153 ch_log(NULL, "channel_free_all()");
Bram Moolenaar77073442016-02-13 23:23:53 +01002154 for (channel = first_channel; channel != NULL; channel = channel->ch_next)
2155 channel_clear(channel);
2156}
2157#endif
2158
2159
Bram Moolenaard04a0202016-01-26 23:30:18 +01002160/* Sent when the channel is found closed when reading. */
Bram Moolenaareed284a2016-02-22 23:13:33 +01002161#define DETACH_MSG_RAW "DETACH\n"
Bram Moolenaard04a0202016-01-26 23:30:18 +01002162
2163/* Buffer size for reading incoming messages. */
2164#define MAXMSGSIZE 4096
2165
2166/*
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002167 * Check for reading from "fd" with "timeout" msec.
2168 * Return FAIL when there is nothing to read.
2169 */
2170 static int
Bram Moolenaard8070362016-02-15 21:56:54 +01002171channel_wait(channel_T *channel, sock_T fd, int timeout)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002172{
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002173 if (timeout > 0)
Bram Moolenaar81661fb2016-02-18 22:23:34 +01002174 ch_logn(channel, "Waiting for up to %d msec", timeout);
Bram Moolenaard8070362016-02-15 21:56:54 +01002175
Bram Moolenaard8070362016-02-15 21:56:54 +01002176# ifdef WIN32
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002177 if (fd != channel->CH_SOCK_FD)
Bram Moolenaard8070362016-02-15 21:56:54 +01002178 {
2179 DWORD nread;
2180 int diff;
2181 DWORD deadline = GetTickCount() + timeout;
2182
2183 /* reading from a pipe, not a socket */
2184 while (TRUE)
2185 {
Bram Moolenaare74e8e72016-02-16 22:01:30 +01002186 if (PeekNamedPipe((HANDLE)fd, NULL, 0, NULL, &nread, NULL)
2187 && nread > 0)
Bram Moolenaard8070362016-02-15 21:56:54 +01002188 return OK;
2189 diff = deadline - GetTickCount();
Bram Moolenaarb7522a22016-02-21 17:20:55 +01002190 if (diff <= 0)
Bram Moolenaard8070362016-02-15 21:56:54 +01002191 break;
2192 /* Wait for 5 msec.
2193 * TODO: increase the sleep time when looping more often */
2194 Sleep(5);
2195 }
Bram Moolenaard8070362016-02-15 21:56:54 +01002196 }
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002197 else
Bram Moolenaard8070362016-02-15 21:56:54 +01002198#endif
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002199 {
Bram Moolenaar9186a272016-02-23 19:34:01 +01002200#if defined(HAVE_SELECT)
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002201 struct timeval tval;
2202 fd_set rfds;
2203 int ret;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002204
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002205 FD_ZERO(&rfds);
2206 FD_SET((int)fd, &rfds);
2207 tval.tv_sec = timeout / 1000;
2208 tval.tv_usec = (timeout % 1000) * 1000;
2209 for (;;)
2210 {
2211 ret = select((int)fd + 1, &rfds, NULL, NULL, &tval);
Bram Moolenaar9186a272016-02-23 19:34:01 +01002212# ifdef EINTR
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002213 SOCK_ERRNO;
2214 if (ret == -1 && errno == EINTR)
2215 continue;
Bram Moolenaar9186a272016-02-23 19:34:01 +01002216# endif
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002217 if (ret > 0)
2218 return OK;
2219 break;
2220 }
Bram Moolenaar9186a272016-02-23 19:34:01 +01002221#else
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002222 struct pollfd fds;
2223
2224 fds.fd = fd;
2225 fds.events = POLLIN;
2226 if (poll(&fds, 1, timeout) > 0)
2227 return OK;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002228#endif
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002229 }
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002230 return FAIL;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002231}
2232
2233/*
2234 * Return a unique ID to be used in a message.
2235 */
2236 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002237channel_get_id(void)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002238{
2239 static int next_id = 1;
2240
2241 return next_id++;
2242}
2243
2244/*
Bram Moolenaar77073442016-02-13 23:23:53 +01002245 * Read from channel "channel" for as long as there is something to read.
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002246 * "part" is PART_SOCK, PART_OUT or PART_ERR.
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002247 * The data is put in the read queue.
Bram Moolenaard04a0202016-01-26 23:30:18 +01002248 */
2249 void
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002250channel_read(channel_T *channel, int part, char *func)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002251{
2252 static char_u *buf = NULL;
2253 int len = 0;
2254 int readlen = 0;
Bram Moolenaard8070362016-02-15 21:56:54 +01002255 sock_T fd;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002256 int use_socket = FALSE;
Bram Moolenaard04a0202016-01-26 23:30:18 +01002257
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002258 fd = channel->ch_part[part].ch_fd;
2259 if (fd == INVALID_FD)
2260 {
2261 ch_error(channel, "channel_read() called while socket is closed");
Bram Moolenaard04a0202016-01-26 23:30:18 +01002262 return;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002263 }
2264 use_socket = fd == channel->CH_SOCK_FD;
Bram Moolenaard04a0202016-01-26 23:30:18 +01002265
2266 /* Allocate a buffer to read into. */
2267 if (buf == NULL)
2268 {
2269 buf = alloc(MAXMSGSIZE);
2270 if (buf == NULL)
2271 return; /* out of memory! */
2272 }
2273
2274 /* Keep on reading for as long as there is something to read.
2275 * Use select() or poll() to avoid blocking on a message that is exactly
2276 * MAXMSGSIZE long. */
2277 for (;;)
2278 {
Bram Moolenaar77073442016-02-13 23:23:53 +01002279 if (channel_wait(channel, fd, 0) == FAIL)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002280 break;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002281 if (use_socket)
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +01002282 len = sock_read(fd, (char *)buf, MAXMSGSIZE);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002283 else
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +01002284 len = fd_read(fd, (char *)buf, MAXMSGSIZE);
Bram Moolenaard04a0202016-01-26 23:30:18 +01002285 if (len <= 0)
2286 break; /* error or nothing more to read */
2287
2288 /* Store the read message in the queue. */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002289 channel_save(channel, part, buf, len);
Bram Moolenaard04a0202016-01-26 23:30:18 +01002290 readlen += len;
2291 if (len < MAXMSGSIZE)
2292 break; /* did read everything that's available */
2293 }
2294
Bram Moolenaar4cafa6d2016-02-26 11:52:39 +01002295 /* Reading a disconnection (readlen == 0), or an error. */
Bram Moolenaarbd73ae12016-02-22 22:19:22 +01002296 if (readlen <= 0)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002297 {
Bram Moolenaar4cafa6d2016-02-26 11:52:39 +01002298 /* Do not give an error message, most likely the other end just
2299 * exited. */
2300 ch_errors(channel, "%s(): Cannot read from channel", func);
2301
Bram Moolenaard04a0202016-01-26 23:30:18 +01002302 /* Queue a "DETACH" netbeans message in the command queue in order to
2303 * terminate the netbeans session later. Do not end the session here
2304 * directly as we may be running in the context of a call to
2305 * netbeans_parse_messages():
2306 * netbeans_parse_messages
2307 * -> autocmd triggered while processing the netbeans cmd
2308 * -> ui_breakcheck
2309 * -> gui event loop or select loop
2310 * -> channel_read()
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +01002311 * Don't send "DETACH" for a JS or JSON channel.
Bram Moolenaard04a0202016-01-26 23:30:18 +01002312 */
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +01002313 if (channel->ch_part[part].ch_mode == MODE_RAW
2314 || channel->ch_part[part].ch_mode == MODE_NL)
2315 channel_save(channel, part, (char_u *)DETACH_MSG_RAW,
2316 (int)STRLEN(DETACH_MSG_RAW));
Bram Moolenaard04a0202016-01-26 23:30:18 +01002317
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002318 /* TODO: When reading from stdout is not possible, should we try to
2319 * keep stdin and stderr open? Probably not, assume the other side
2320 * has died. */
Bram Moolenaar8b374212016-02-24 20:43:06 +01002321 channel_close(channel, TRUE);
Bram Moolenaar4e221c92016-02-23 13:20:22 +01002322 if (channel->ch_nb_close_cb != NULL)
2323 (*channel->ch_nb_close_cb)();
Bram Moolenaard04a0202016-01-26 23:30:18 +01002324 }
2325
2326#if defined(CH_HAS_GUI) && defined(FEAT_GUI_GTK)
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002327 /* signal the main loop that there is something to read */
Bram Moolenaard04a0202016-01-26 23:30:18 +01002328 if (CH_HAS_GUI && gtk_main_level() > 0)
2329 gtk_main_quit();
2330#endif
2331}
2332
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002333/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002334 * Read from RAW or NL "channel"/"part". Blocks until there is something to
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002335 * read or the timeout expires.
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002336 * Returns what was read in allocated memory.
2337 * Returns NULL in case of error or timeout.
2338 */
2339 char_u *
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01002340channel_read_block(channel_T *channel, int part, int timeout)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002341{
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002342 char_u *buf;
2343 char_u *msg;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002344 ch_mode_T mode = channel->ch_part[part].ch_mode;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002345 sock_T fd = channel->ch_part[part].ch_fd;
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002346 char_u *nl;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002347
Bram Moolenaar81661fb2016-02-18 22:23:34 +01002348 ch_logsn(channel, "Blocking %s read, timeout: %d msec",
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002349 mode == MODE_RAW ? "RAW" : "NL", timeout);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002350
2351 while (TRUE)
2352 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002353 buf = channel_peek(channel, part);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002354 if (buf != NULL && (mode == MODE_RAW
2355 || (mode == MODE_NL && vim_strchr(buf, NL) != NULL)))
2356 break;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002357 if (buf != NULL && channel_collapse(channel, part) == OK)
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002358 continue;
2359
Bram Moolenaar4d919d72016-02-05 22:36:41 +01002360 /* Wait for up to the channel timeout. */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002361 if (fd == INVALID_FD
2362 || channel_wait(channel, fd, timeout) == FAIL)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002363 return NULL;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002364 channel_read(channel, part, "channel_read_block");
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002365 }
2366
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002367 if (mode == MODE_RAW)
2368 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002369 msg = channel_get_all(channel, part);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002370 }
2371 else
2372 {
2373 nl = vim_strchr(buf, NL);
2374 if (nl[1] == NUL)
2375 {
2376 /* get the whole buffer */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002377 msg = channel_get(channel, part);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002378 *nl = NUL;
2379 }
2380 else
2381 {
2382 /* Copy the message into allocated memory and remove it from the
2383 * buffer. */
2384 msg = vim_strnsave(buf, (int)(nl - buf));
2385 mch_memmove(buf, nl + 1, STRLEN(nl + 1) + 1);
2386 }
2387 }
2388 if (log_fd != NULL)
Bram Moolenaar81661fb2016-02-18 22:23:34 +01002389 ch_logn(channel, "Returning %d bytes", (int)STRLEN(msg));
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002390 return msg;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002391}
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002392
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002393/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002394 * Read one JSON message with ID "id" from "channel"/"part" and store the
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002395 * result in "rettv".
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01002396 * When "id" is -1 accept any message;
Bram Moolenaar4d919d72016-02-05 22:36:41 +01002397 * Blocks until the message is received or the timeout is reached.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002398 */
2399 int
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01002400channel_read_json_block(
Bram Moolenaard6051b52016-02-28 15:49:03 +01002401 channel_T *channel,
2402 int part,
2403 int timeout,
2404 int id,
2405 typval_T **rettv)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002406{
Bram Moolenaare56bf152016-02-08 23:23:42 +01002407 int more;
Bram Moolenaard8070362016-02-15 21:56:54 +01002408 sock_T fd;
Bram Moolenaard7ece102016-02-02 23:23:02 +01002409
Bram Moolenaar81661fb2016-02-18 22:23:34 +01002410 ch_log(channel, "Reading JSON");
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01002411 if (id != -1)
2412 channel->ch_part[part].ch_block_id = id;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002413 for (;;)
2414 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002415 more = channel_parse_json(channel, part);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002416
2417 /* search for messsage "id" */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002418 if (channel_get_json(channel, part, id, rettv) == OK)
Bram Moolenaare56bf152016-02-08 23:23:42 +01002419 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002420 channel->ch_part[part].ch_block_id = 0;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002421 return OK;
Bram Moolenaare56bf152016-02-08 23:23:42 +01002422 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002423
Bram Moolenaard7ece102016-02-02 23:23:02 +01002424 if (!more)
2425 {
2426 /* Handle any other messages in the queue. If done some more
2427 * messages may have arrived. */
2428 if (channel_parse_messages())
2429 continue;
2430
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01002431 /* Wait for up to the timeout. */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002432 fd = channel->ch_part[part].ch_fd;
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01002433 if (fd == INVALID_FD || channel_wait(channel, fd, timeout) == FAIL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01002434 break;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002435 channel_read(channel, part, "channel_read_json_block");
Bram Moolenaard7ece102016-02-02 23:23:02 +01002436 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002437 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002438 channel->ch_part[part].ch_block_id = 0;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002439 return FAIL;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002440}
2441
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01002442/*
2443 * Common for ch_read() and ch_readraw().
2444 */
2445 void
2446common_channel_read(typval_T *argvars, typval_T *rettv, int raw)
2447{
2448 channel_T *channel;
2449 int part;
2450 jobopt_T opt;
2451 int mode;
2452 int timeout;
2453 int id = -1;
2454 typval_T *listtv = NULL;
2455
2456 /* return an empty string by default */
2457 rettv->v_type = VAR_STRING;
2458 rettv->vval.v_string = NULL;
2459
2460 clear_job_options(&opt);
2461 if (get_job_options(&argvars[1], &opt, JO_TIMEOUT + JO_PART + JO_ID)
2462 == FAIL)
2463 return;
2464
2465 channel = get_channel_arg(&argvars[0], TRUE);
2466 if (channel != NULL)
2467 {
2468 if (opt.jo_set & JO_PART)
2469 part = opt.jo_part;
2470 else
2471 part = channel_part_read(channel);
2472 mode = channel_get_mode(channel, part);
2473 timeout = channel_get_timeout(channel, part);
2474 if (opt.jo_set & JO_TIMEOUT)
2475 timeout = opt.jo_timeout;
2476
2477 if (raw || mode == MODE_RAW || mode == MODE_NL)
2478 rettv->vval.v_string = channel_read_block(channel, part, timeout);
2479 else
2480 {
2481 if (opt.jo_set & JO_ID)
2482 id = opt.jo_id;
2483 channel_read_json_block(channel, part, timeout, id, &listtv);
2484 if (listtv != NULL)
2485 {
2486 *rettv = *listtv;
2487 vim_free(listtv);
2488 }
2489 else
2490 {
2491 rettv->v_type = VAR_SPECIAL;
2492 rettv->vval.v_number = VVAL_NONE;
2493 }
2494 }
2495 }
2496}
2497
Bram Moolenaarfffd5562016-02-20 18:44:39 +01002498# if defined(WIN32) || defined(FEAT_GUI_X11) || defined(FEAT_GUI_GTK) \
2499 || defined(PROTO)
Bram Moolenaar85be35f2016-01-27 21:08:18 +01002500/*
Bram Moolenaarfffd5562016-02-20 18:44:39 +01002501 * Lookup the channel from the socket. Set "partp" to the fd index.
Bram Moolenaar77073442016-02-13 23:23:53 +01002502 * Returns NULL when the socket isn't found.
Bram Moolenaar85be35f2016-01-27 21:08:18 +01002503 */
Bram Moolenaar77073442016-02-13 23:23:53 +01002504 channel_T *
Bram Moolenaarfffd5562016-02-20 18:44:39 +01002505channel_fd2channel(sock_T fd, int *partp)
Bram Moolenaar85be35f2016-01-27 21:08:18 +01002506{
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002507 channel_T *channel;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002508 int part;
Bram Moolenaar85be35f2016-01-27 21:08:18 +01002509
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002510 if (fd != INVALID_FD)
Bram Moolenaar77073442016-02-13 23:23:53 +01002511 for (channel = first_channel; channel != NULL;
2512 channel = channel->ch_next)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002513 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002514 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002515 if (channel->ch_part[part].ch_fd == fd)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002516 {
Bram Moolenaarfffd5562016-02-20 18:44:39 +01002517 *partp = part;
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002518 return channel;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002519 }
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002520 }
Bram Moolenaar77073442016-02-13 23:23:53 +01002521 return NULL;
Bram Moolenaar85be35f2016-01-27 21:08:18 +01002522}
Bram Moolenaarb7522a22016-02-21 17:20:55 +01002523# endif
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002524
Bram Moolenaarb7522a22016-02-21 17:20:55 +01002525# if defined(WIN32) || defined(PROTO)
2526/*
2527 * Check the channels for anything that is ready to be read.
2528 * The data is put in the read queue.
2529 */
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002530 void
2531channel_handle_events(void)
2532{
2533 channel_T *channel;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002534 int part;
Bram Moolenaarb7522a22016-02-21 17:20:55 +01002535 sock_T fd;
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002536
2537 for (channel = first_channel; channel != NULL; channel = channel->ch_next)
2538 {
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002539 /* check the socket and pipes */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002540 for (part = PART_SOCK; part <= PART_ERR; ++part)
Bram Moolenaarb7522a22016-02-21 17:20:55 +01002541 {
2542 fd = channel->ch_part[part].ch_fd;
2543 if (fd != INVALID_FD && channel_wait(channel, fd, 0) == OK)
2544 channel_read(channel, part, "channel_handle_events");
2545 }
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002546 }
2547}
Bram Moolenaar85be35f2016-01-27 21:08:18 +01002548# endif
2549
Bram Moolenaard04a0202016-01-26 23:30:18 +01002550/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002551 * Write "buf" (NUL terminated string) to "channel"/"part".
Bram Moolenaard04a0202016-01-26 23:30:18 +01002552 * When "fun" is not NULL an error message might be given.
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002553 * Return FAIL or OK.
Bram Moolenaard04a0202016-01-26 23:30:18 +01002554 */
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002555 int
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002556channel_send(channel_T *channel, int part, char_u *buf, char *fun)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002557{
Bram Moolenaard04a0202016-01-26 23:30:18 +01002558 int len = (int)STRLEN(buf);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002559 int res;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002560 sock_T fd;
Bram Moolenaard04a0202016-01-26 23:30:18 +01002561
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002562 fd = channel->ch_part[part].ch_fd;
2563 if (fd == INVALID_FD)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002564 {
2565 if (!channel->ch_error && fun != NULL)
2566 {
Bram Moolenaar81661fb2016-02-18 22:23:34 +01002567 ch_errors(channel, "%s(): write while not connected", fun);
Bram Moolenaard04a0202016-01-26 23:30:18 +01002568 EMSG2("E630: %s(): write while not connected", fun);
2569 }
2570 channel->ch_error = TRUE;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002571 return FAIL;
Bram Moolenaard04a0202016-01-26 23:30:18 +01002572 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002573
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002574 if (log_fd != NULL)
2575 {
Bram Moolenaar77073442016-02-13 23:23:53 +01002576 ch_log_lead("SEND ", channel);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002577 fprintf(log_fd, "'");
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002578 ignored = (int)fwrite(buf, len, 1, log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002579 fprintf(log_fd, "'\n");
2580 fflush(log_fd);
Bram Moolenaard0b65022016-03-06 21:50:33 +01002581 did_log_msg = TRUE;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002582 }
2583
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002584 if (part == PART_SOCK)
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +01002585 res = sock_write(fd, (char *)buf, len);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002586 else
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +01002587 res = fd_write(fd, (char *)buf, len);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002588 if (res != len)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002589 {
2590 if (!channel->ch_error && fun != NULL)
2591 {
Bram Moolenaar81661fb2016-02-18 22:23:34 +01002592 ch_errors(channel, "%s(): write failed", fun);
Bram Moolenaard04a0202016-01-26 23:30:18 +01002593 EMSG2("E631: %s(): write failed", fun);
2594 }
2595 channel->ch_error = TRUE;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002596 return FAIL;
Bram Moolenaard04a0202016-01-26 23:30:18 +01002597 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002598
2599 channel->ch_error = FALSE;
2600 return OK;
Bram Moolenaard04a0202016-01-26 23:30:18 +01002601}
2602
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01002603/*
2604 * Common for "ch_sendexpr()" and "ch_sendraw()".
2605 * Returns the channel if the caller should read the response.
2606 * Sets "part_read" to the the read fd.
2607 * Otherwise returns NULL.
2608 */
2609 channel_T *
2610send_common(
2611 typval_T *argvars,
2612 char_u *text,
2613 int id,
2614 int eval,
2615 jobopt_T *opt,
2616 char *fun,
2617 int *part_read)
2618{
2619 channel_T *channel;
2620 int part_send;
2621
2622 channel = get_channel_arg(&argvars[0], TRUE);
2623 if (channel == NULL)
2624 return NULL;
2625 part_send = channel_part_send(channel);
2626 *part_read = channel_part_read(channel);
2627
2628 clear_job_options(opt);
2629 if (get_job_options(&argvars[2], opt, JO_CALLBACK + JO_TIMEOUT) == FAIL)
2630 return NULL;
2631
2632 /* Set the callback. An empty callback means no callback and not reading
2633 * the response. With "ch_evalexpr()" and "ch_evalraw()" a callback is not
2634 * allowed. */
2635 if (opt->jo_callback != NULL && *opt->jo_callback != NUL)
2636 {
2637 if (eval)
2638 {
2639 EMSG2(_("E917: Cannot use a callback with %s()"), fun);
2640 return NULL;
2641 }
Bram Moolenaar1735bc92016-03-14 23:05:14 +01002642 channel_set_req_callback(channel, part_send,
2643 opt->jo_callback, opt->jo_partial, id);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01002644 }
2645
2646 if (channel_send(channel, part_send, text, fun) == OK
2647 && opt->jo_callback == NULL)
2648 return channel;
2649 return NULL;
2650}
2651
2652/*
2653 * common for "ch_evalexpr()" and "ch_sendexpr()"
2654 */
2655 void
2656ch_expr_common(typval_T *argvars, typval_T *rettv, int eval)
2657{
2658 char_u *text;
2659 typval_T *listtv;
2660 channel_T *channel;
2661 int id;
2662 ch_mode_T ch_mode;
2663 int part_send;
2664 int part_read;
2665 jobopt_T opt;
2666 int timeout;
2667
2668 /* return an empty string by default */
2669 rettv->v_type = VAR_STRING;
2670 rettv->vval.v_string = NULL;
2671
2672 channel = get_channel_arg(&argvars[0], TRUE);
2673 if (channel == NULL)
2674 return;
2675 part_send = channel_part_send(channel);
2676
2677 ch_mode = channel_get_mode(channel, part_send);
2678 if (ch_mode == MODE_RAW || ch_mode == MODE_NL)
2679 {
2680 EMSG(_("E912: cannot use ch_evalexpr()/ch_sendexpr() with a raw or nl channel"));
2681 return;
2682 }
2683
2684 id = channel_get_id();
2685 text = json_encode_nr_expr(id, &argvars[1],
2686 ch_mode == MODE_JS ? JSON_JS : 0);
2687 if (text == NULL)
2688 return;
2689
2690 channel = send_common(argvars, text, id, eval, &opt,
2691 eval ? "ch_evalexpr" : "ch_sendexpr", &part_read);
2692 vim_free(text);
2693 if (channel != NULL && eval)
2694 {
2695 if (opt.jo_set & JO_TIMEOUT)
2696 timeout = opt.jo_timeout;
2697 else
2698 timeout = channel_get_timeout(channel, part_read);
2699 timeout = channel_get_timeout(channel, part_read);
2700 if (channel_read_json_block(channel, part_read, timeout, id, &listtv)
2701 == OK)
2702 {
2703 list_T *list = listtv->vval.v_list;
2704
2705 /* Move the item from the list and then change the type to
2706 * avoid the value being freed. */
2707 *rettv = list->lv_last->li_tv;
2708 list->lv_last->li_tv.v_type = VAR_NUMBER;
2709 free_tv(listtv);
2710 }
2711 }
2712}
2713
2714/*
2715 * common for "ch_evalraw()" and "ch_sendraw()"
2716 */
2717 void
2718ch_raw_common(typval_T *argvars, typval_T *rettv, int eval)
2719{
2720 char_u buf[NUMBUFLEN];
2721 char_u *text;
2722 channel_T *channel;
2723 int part_read;
2724 jobopt_T opt;
2725 int timeout;
2726
2727 /* return an empty string by default */
2728 rettv->v_type = VAR_STRING;
2729 rettv->vval.v_string = NULL;
2730
2731 text = get_tv_string_buf(&argvars[1], buf);
2732 channel = send_common(argvars, text, 0, eval, &opt,
2733 eval ? "ch_evalraw" : "ch_sendraw", &part_read);
2734 if (channel != NULL && eval)
2735 {
2736 if (opt.jo_set & JO_TIMEOUT)
2737 timeout = opt.jo_timeout;
2738 else
2739 timeout = channel_get_timeout(channel, part_read);
2740 rettv->vval.v_string = channel_read_block(channel, part_read, timeout);
2741 }
2742}
2743
Bram Moolenaard04a0202016-01-26 23:30:18 +01002744# if (defined(UNIX) && !defined(HAVE_SELECT)) || defined(PROTO)
Bram Moolenaare0874f82016-01-24 20:36:41 +01002745/*
2746 * Add open channels to the poll struct.
2747 * Return the adjusted struct index.
2748 * The type of "fds" is hidden to avoid problems with the function proto.
2749 */
2750 int
2751channel_poll_setup(int nfd_in, void *fds_in)
2752{
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002753 int nfd = nfd_in;
2754 channel_T *channel;
2755 struct pollfd *fds = fds_in;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002756 int part;
Bram Moolenaare0874f82016-01-24 20:36:41 +01002757
Bram Moolenaar77073442016-02-13 23:23:53 +01002758 for (channel = first_channel; channel != NULL; channel = channel->ch_next)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002759 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002760 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002761 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002762 if (channel->ch_part[part].ch_fd != INVALID_FD)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002763 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002764 channel->ch_part[part].ch_poll_idx = nfd;
2765 fds[nfd].fd = channel->ch_part[part].ch_fd;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002766 fds[nfd].events = POLLIN;
2767 nfd++;
2768 }
2769 else
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002770 channel->ch_part[part].ch_poll_idx = -1;
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002771 }
2772 }
Bram Moolenaare0874f82016-01-24 20:36:41 +01002773
2774 return nfd;
2775}
2776
2777/*
2778 * The type of "fds" is hidden to avoid problems with the function proto.
2779 */
2780 int
2781channel_poll_check(int ret_in, void *fds_in)
2782{
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002783 int ret = ret_in;
2784 channel_T *channel;
2785 struct pollfd *fds = fds_in;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002786 int part;
Bram Moolenaare0874f82016-01-24 20:36:41 +01002787
Bram Moolenaar77073442016-02-13 23:23:53 +01002788 for (channel = first_channel; channel != NULL; channel = channel->ch_next)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002789 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002790 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002791 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002792 int idx = channel->ch_part[part].ch_poll_idx;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002793
2794 if (ret > 0 && idx != -1 && fds[idx].revents & POLLIN)
2795 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002796 channel_read(channel, part, "channel_poll_check");
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002797 --ret;
2798 }
2799 }
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002800 }
Bram Moolenaare0874f82016-01-24 20:36:41 +01002801
2802 return ret;
2803}
Bram Moolenaard04a0202016-01-26 23:30:18 +01002804# endif /* UNIX && !HAVE_SELECT */
Bram Moolenaare0874f82016-01-24 20:36:41 +01002805
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002806# if (!defined(WIN32) && defined(HAVE_SELECT)) || defined(PROTO)
Bram Moolenaare0874f82016-01-24 20:36:41 +01002807/*
2808 * The type of "rfds" is hidden to avoid problems with the function proto.
2809 */
2810 int
2811channel_select_setup(int maxfd_in, void *rfds_in)
2812{
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002813 int maxfd = maxfd_in;
2814 channel_T *channel;
2815 fd_set *rfds = rfds_in;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002816 int part;
Bram Moolenaare0874f82016-01-24 20:36:41 +01002817
Bram Moolenaar77073442016-02-13 23:23:53 +01002818 for (channel = first_channel; channel != NULL; channel = channel->ch_next)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002819 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002820 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002821 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002822 sock_T fd = channel->ch_part[part].ch_fd;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002823
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002824 if (fd != INVALID_FD)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002825 {
Bram Moolenaard8070362016-02-15 21:56:54 +01002826 FD_SET((int)fd, rfds);
2827 if (maxfd < (int)fd)
2828 maxfd = (int)fd;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002829 }
2830 }
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002831 }
Bram Moolenaare0874f82016-01-24 20:36:41 +01002832
2833 return maxfd;
2834}
2835
2836/*
2837 * The type of "rfds" is hidden to avoid problems with the function proto.
2838 */
2839 int
2840channel_select_check(int ret_in, void *rfds_in)
2841{
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002842 int ret = ret_in;
2843 channel_T *channel;
2844 fd_set *rfds = rfds_in;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002845 int part;
Bram Moolenaare0874f82016-01-24 20:36:41 +01002846
Bram Moolenaar77073442016-02-13 23:23:53 +01002847 for (channel = first_channel; channel != NULL; channel = channel->ch_next)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002848 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002849 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002850 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002851 sock_T fd = channel->ch_part[part].ch_fd;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002852
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002853 if (ret > 0 && fd != INVALID_FD && FD_ISSET(fd, rfds))
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002854 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002855 channel_read(channel, part, "channel_select_check");
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01002856 --ret;
2857 }
2858 }
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01002859 }
Bram Moolenaare0874f82016-01-24 20:36:41 +01002860
2861 return ret;
2862}
Bram Moolenaared5a78e2016-02-19 21:05:03 +01002863# endif /* !WIN32 && HAVE_SELECT */
Bram Moolenaare0874f82016-01-24 20:36:41 +01002864
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002865/*
Bram Moolenaar187db502016-02-27 14:44:26 +01002866 * Return TRUE if "channel" has JSON or other typeahead.
2867 */
2868 static int
2869channel_has_readahead(channel_T *channel, int part)
2870{
2871 ch_mode_T ch_mode = channel->ch_part[part].ch_mode;
2872
2873 if (ch_mode == MODE_JSON || ch_mode == MODE_JS)
2874 {
2875 jsonq_T *head = &channel->ch_part[part].ch_json_head;
2876 jsonq_T *item = head->jq_next;
2877
2878 return item != NULL;
2879 }
2880 return channel_peek(channel, part) != NULL;
2881}
2882
2883/*
Bram Moolenaard7ece102016-02-02 23:23:02 +01002884 * Execute queued up commands.
2885 * Invoked from the main loop when it's safe to execute received commands.
2886 * Return TRUE when something was done.
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002887 */
Bram Moolenaard7ece102016-02-02 23:23:02 +01002888 int
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002889channel_parse_messages(void)
2890{
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01002891 channel_T *channel = first_channel;
2892 int ret = FALSE;
2893 int r;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002894 int part = PART_SOCK;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002895
Bram Moolenaard0b65022016-03-06 21:50:33 +01002896 /* Only do this message when another message was given, otherwise we get
2897 * lots of them. */
2898 if (did_log_msg)
2899 {
2900 ch_log(NULL, "looking for messages on channels");
2901 did_log_msg = FALSE;
2902 }
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01002903 while (channel != NULL)
2904 {
Bram Moolenaar46c85432016-02-26 11:17:46 +01002905 if (channel->ch_refcount == 0 && !channel_still_useful(channel))
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +01002906 {
2907 /* channel is no longer useful, free it */
2908 channel_free(channel);
2909 channel = first_channel;
2910 part = PART_SOCK;
2911 continue;
2912 }
Bram Moolenaar187db502016-02-27 14:44:26 +01002913 if (channel->ch_part[part].ch_fd != INVALID_FD
2914 || channel_has_readahead(channel, part))
Bram Moolenaard7ece102016-02-02 23:23:02 +01002915 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002916 /* Increase the refcount, in case the handler causes the channel
2917 * to be unreferenced or closed. */
2918 ++channel->ch_refcount;
2919 r = may_invoke_callback(channel, part);
2920 if (r == OK)
2921 ret = TRUE;
2922 if (channel_unref(channel) || r == OK)
2923 {
2924 /* channel was freed or something was done, start over */
2925 channel = first_channel;
2926 part = PART_SOCK;
2927 continue;
2928 }
Bram Moolenaard7ece102016-02-02 23:23:02 +01002929 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002930 if (part < PART_ERR)
2931 ++part;
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01002932 else
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002933 {
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01002934 channel = channel->ch_next;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002935 part = PART_SOCK;
2936 }
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01002937 }
Bram Moolenaar187db502016-02-27 14:44:26 +01002938
2939 if (channel_need_redraw && must_redraw)
2940 {
2941 channel_need_redraw = FALSE;
2942 update_screen(0);
2943 setcursor();
2944 cursor_on();
2945 out_flush();
2946 }
2947
Bram Moolenaard7ece102016-02-02 23:23:02 +01002948 return ret;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002949}
2950
Bram Moolenaarfbc4b4d2016-02-07 15:14:01 +01002951/*
2952 * Mark references to lists used in channels.
2953 */
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01002954 int
2955set_ref_in_channel(int copyID)
2956{
Bram Moolenaar77073442016-02-13 23:23:53 +01002957 int abort = FALSE;
2958 channel_T *channel;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002959 int part;
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01002960
Bram Moolenaar77073442016-02-13 23:23:53 +01002961 for (channel = first_channel; channel != NULL; channel = channel->ch_next)
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01002962 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002963 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01002964 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002965 jsonq_T *head = &channel->ch_part[part].ch_json_head;
2966 jsonq_T *item = head->jq_next;
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01002967
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002968 while (item != NULL)
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01002969 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002970 list_T *l = item->jq_value->vval.v_list;
2971
2972 if (l->lv_copyID != copyID)
2973 {
2974 l->lv_copyID = copyID;
2975 abort = abort || set_ref_in_list(l, copyID, NULL);
2976 }
2977 item = item->jq_next;
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01002978 }
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01002979 }
2980 }
2981 return abort;
2982}
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01002983
2984/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002985 * Return the "part" to write to for "channel".
2986 */
2987 int
2988channel_part_send(channel_T *channel)
2989{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002990 if (channel->CH_SOCK_FD == INVALID_FD)
2991 return PART_IN;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002992 return PART_SOCK;
2993}
2994
2995/*
2996 * Return the default "part" to read from for "channel".
2997 */
2998 int
2999channel_part_read(channel_T *channel)
3000{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003001 if (channel->CH_SOCK_FD == INVALID_FD)
3002 return PART_OUT;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003003 return PART_SOCK;
3004}
3005
3006/*
3007 * Return the mode of "channel"/"part"
Bram Moolenaar77073442016-02-13 23:23:53 +01003008 * If "channel" is invalid returns MODE_JSON.
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01003009 */
3010 ch_mode_T
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003011channel_get_mode(channel_T *channel, int part)
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01003012{
Bram Moolenaar77073442016-02-13 23:23:53 +01003013 if (channel == NULL)
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01003014 return MODE_JSON;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003015 return channel->ch_part[part].ch_mode;
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01003016}
3017
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01003018/*
3019 * Return the timeout of "channel"/"part"
3020 */
3021 int
3022channel_get_timeout(channel_T *channel, int part)
3023{
3024 return channel->ch_part[part].ch_timeout;
3025}
3026
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003027/*
3028 * Get a callback from "arg". It can be a Funcref or a function name.
3029 * When "arg" is zero return an empty string.
3030 * Return NULL for an invalid argument.
3031 */
3032 static char_u *
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003033get_callback(typval_T *arg, partial_T **pp)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003034{
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003035 if (arg->v_type == VAR_PARTIAL && arg->vval.v_partial != NULL)
3036 {
3037 *pp = arg->vval.v_partial;
3038 return (*pp)->pt_name;
3039 }
3040 *pp = NULL;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003041 if (arg->v_type == VAR_FUNC || arg->v_type == VAR_STRING)
3042 return arg->vval.v_string;
3043 if (arg->v_type == VAR_NUMBER && arg->vval.v_number == 0)
3044 return (char_u *)"";
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003045 EMSG(_("E921: Invalid callback argument"));
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003046 return NULL;
3047}
3048
3049 static int
3050handle_mode(typval_T *item, jobopt_T *opt, ch_mode_T *modep, int jo)
3051{
3052 char_u *val = get_tv_string(item);
3053
3054 opt->jo_set |= jo;
3055 if (STRCMP(val, "nl") == 0)
3056 *modep = MODE_NL;
3057 else if (STRCMP(val, "raw") == 0)
3058 *modep = MODE_RAW;
3059 else if (STRCMP(val, "js") == 0)
3060 *modep = MODE_JS;
3061 else if (STRCMP(val, "json") == 0)
3062 *modep = MODE_JSON;
3063 else
3064 {
3065 EMSG2(_(e_invarg2), val);
3066 return FAIL;
3067 }
3068 return OK;
3069}
3070
3071 static int
3072handle_io(typval_T *item, int part, jobopt_T *opt)
3073{
3074 char_u *val = get_tv_string(item);
3075
3076 opt->jo_set |= JO_OUT_IO << (part - PART_OUT);
3077 if (STRCMP(val, "null") == 0)
3078 opt->jo_io[part] = JIO_NULL;
3079 else if (STRCMP(val, "pipe") == 0)
3080 opt->jo_io[part] = JIO_PIPE;
3081 else if (STRCMP(val, "file") == 0)
3082 opt->jo_io[part] = JIO_FILE;
3083 else if (STRCMP(val, "buffer") == 0)
3084 opt->jo_io[part] = JIO_BUFFER;
3085 else if (STRCMP(val, "out") == 0 && part == PART_ERR)
3086 opt->jo_io[part] = JIO_OUT;
3087 else
3088 {
3089 EMSG2(_(e_invarg2), val);
3090 return FAIL;
3091 }
3092 return OK;
3093}
3094
3095 void
3096clear_job_options(jobopt_T *opt)
3097{
3098 vim_memset(opt, 0, sizeof(jobopt_T));
3099}
3100
3101/*
3102 * Get the PART_ number from the first character of an option name.
3103 */
3104 static int
3105part_from_char(int c)
3106{
3107 return c == 'i' ? PART_IN : c == 'o' ? PART_OUT: PART_ERR;
3108}
3109
3110/*
3111 * Get the option entries from the dict in "tv", parse them and put the result
3112 * in "opt".
3113 * Only accept options in "supported".
3114 * If an option value is invalid return FAIL.
3115 */
3116 int
3117get_job_options(typval_T *tv, jobopt_T *opt, int supported)
3118{
3119 typval_T *item;
3120 char_u *val;
3121 dict_T *dict;
3122 int todo;
3123 hashitem_T *hi;
3124 int part;
3125
3126 opt->jo_set = 0;
3127 if (tv->v_type == VAR_UNKNOWN)
3128 return OK;
3129 if (tv->v_type != VAR_DICT)
3130 {
3131 EMSG(_(e_invarg));
3132 return FAIL;
3133 }
3134 dict = tv->vval.v_dict;
3135 if (dict == NULL)
3136 return OK;
3137
3138 todo = (int)dict->dv_hashtab.ht_used;
3139 for (hi = dict->dv_hashtab.ht_array; todo > 0; ++hi)
3140 if (!HASHITEM_EMPTY(hi))
3141 {
3142 item = &dict_lookup(hi)->di_tv;
3143
3144 if (STRCMP(hi->hi_key, "mode") == 0)
3145 {
3146 if (!(supported & JO_MODE))
3147 break;
3148 if (handle_mode(item, opt, &opt->jo_mode, JO_MODE) == FAIL)
3149 return FAIL;
3150 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003151 else if (STRCMP(hi->hi_key, "in_mode") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003152 {
3153 if (!(supported & JO_IN_MODE))
3154 break;
3155 if (handle_mode(item, opt, &opt->jo_in_mode, JO_IN_MODE)
3156 == FAIL)
3157 return FAIL;
3158 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003159 else if (STRCMP(hi->hi_key, "out_mode") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003160 {
3161 if (!(supported & JO_OUT_MODE))
3162 break;
3163 if (handle_mode(item, opt, &opt->jo_out_mode, JO_OUT_MODE)
3164 == FAIL)
3165 return FAIL;
3166 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003167 else if (STRCMP(hi->hi_key, "err_mode") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003168 {
3169 if (!(supported & JO_ERR_MODE))
3170 break;
3171 if (handle_mode(item, opt, &opt->jo_err_mode, JO_ERR_MODE)
3172 == FAIL)
3173 return FAIL;
3174 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003175 else if (STRCMP(hi->hi_key, "in_io") == 0
3176 || STRCMP(hi->hi_key, "out_io") == 0
3177 || STRCMP(hi->hi_key, "err_io") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003178 {
3179 if (!(supported & JO_OUT_IO))
3180 break;
3181 if (handle_io(item, part_from_char(*hi->hi_key), opt) == FAIL)
3182 return FAIL;
3183 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003184 else if (STRCMP(hi->hi_key, "in_name") == 0
3185 || STRCMP(hi->hi_key, "out_name") == 0
3186 || STRCMP(hi->hi_key, "err_name") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003187 {
3188 part = part_from_char(*hi->hi_key);
3189
3190 if (!(supported & JO_OUT_IO))
3191 break;
3192 opt->jo_set |= JO_OUT_NAME << (part - PART_OUT);
3193 opt->jo_io_name[part] =
3194 get_tv_string_buf_chk(item, opt->jo_io_name_buf[part]);
3195 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003196 else if (STRCMP(hi->hi_key, "in_buf") == 0
3197 || STRCMP(hi->hi_key, "out_buf") == 0
3198 || STRCMP(hi->hi_key, "err_buf") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003199 {
3200 part = part_from_char(*hi->hi_key);
3201
3202 if (!(supported & JO_OUT_IO))
3203 break;
3204 opt->jo_set |= JO_OUT_BUF << (part - PART_OUT);
3205 opt->jo_io_buf[part] = get_tv_number(item);
3206 if (opt->jo_io_buf[part] <= 0)
3207 {
3208 EMSG2(_(e_invarg2), get_tv_string(item));
3209 return FAIL;
3210 }
3211 if (buflist_findnr(opt->jo_io_buf[part]) == NULL)
3212 {
3213 EMSGN(_(e_nobufnr), (long)opt->jo_io_buf[part]);
3214 return FAIL;
3215 }
3216 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003217 else if (STRCMP(hi->hi_key, "in_top") == 0
3218 || STRCMP(hi->hi_key, "in_bot") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003219 {
3220 linenr_T *lp;
3221
3222 if (!(supported & JO_OUT_IO))
3223 break;
3224 if (hi->hi_key[3] == 't')
3225 {
3226 lp = &opt->jo_in_top;
3227 opt->jo_set |= JO_IN_TOP;
3228 }
3229 else
3230 {
3231 lp = &opt->jo_in_bot;
3232 opt->jo_set |= JO_IN_BOT;
3233 }
3234 *lp = get_tv_number(item);
3235 if (*lp < 0)
3236 {
3237 EMSG2(_(e_invarg2), get_tv_string(item));
3238 return FAIL;
3239 }
3240 }
3241 else if (STRCMP(hi->hi_key, "channel") == 0)
3242 {
3243 if (!(supported & JO_OUT_IO))
3244 break;
3245 opt->jo_set |= JO_CHANNEL;
3246 if (item->v_type != VAR_CHANNEL)
3247 {
3248 EMSG2(_(e_invarg2), "channel");
3249 return FAIL;
3250 }
3251 opt->jo_channel = item->vval.v_channel;
3252 }
3253 else if (STRCMP(hi->hi_key, "callback") == 0)
3254 {
3255 if (!(supported & JO_CALLBACK))
3256 break;
3257 opt->jo_set |= JO_CALLBACK;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003258 opt->jo_callback = get_callback(item, &opt->jo_partial);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003259 if (opt->jo_callback == NULL)
3260 {
3261 EMSG2(_(e_invarg2), "callback");
3262 return FAIL;
3263 }
3264 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003265 else if (STRCMP(hi->hi_key, "out_cb") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003266 {
3267 if (!(supported & JO_OUT_CALLBACK))
3268 break;
3269 opt->jo_set |= JO_OUT_CALLBACK;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003270 opt->jo_out_cb = get_callback(item, &opt->jo_out_partial);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003271 if (opt->jo_out_cb == NULL)
3272 {
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003273 EMSG2(_(e_invarg2), "out_cb");
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003274 return FAIL;
3275 }
3276 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003277 else if (STRCMP(hi->hi_key, "err_cb") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003278 {
3279 if (!(supported & JO_ERR_CALLBACK))
3280 break;
3281 opt->jo_set |= JO_ERR_CALLBACK;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003282 opt->jo_err_cb = get_callback(item, &opt->jo_err_partial);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003283 if (opt->jo_err_cb == NULL)
3284 {
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003285 EMSG2(_(e_invarg2), "err_cb");
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003286 return FAIL;
3287 }
3288 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003289 else if (STRCMP(hi->hi_key, "close_cb") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003290 {
3291 if (!(supported & JO_CLOSE_CALLBACK))
3292 break;
3293 opt->jo_set |= JO_CLOSE_CALLBACK;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003294 opt->jo_close_cb = get_callback(item, &opt->jo_close_partial);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003295 if (opt->jo_close_cb == NULL)
3296 {
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003297 EMSG2(_(e_invarg2), "close_cb");
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003298 return FAIL;
3299 }
3300 }
3301 else if (STRCMP(hi->hi_key, "waittime") == 0)
3302 {
3303 if (!(supported & JO_WAITTIME))
3304 break;
3305 opt->jo_set |= JO_WAITTIME;
3306 opt->jo_waittime = get_tv_number(item);
3307 }
3308 else if (STRCMP(hi->hi_key, "timeout") == 0)
3309 {
3310 if (!(supported & JO_TIMEOUT))
3311 break;
3312 opt->jo_set |= JO_TIMEOUT;
3313 opt->jo_timeout = get_tv_number(item);
3314 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003315 else if (STRCMP(hi->hi_key, "out_timeout") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003316 {
3317 if (!(supported & JO_OUT_TIMEOUT))
3318 break;
3319 opt->jo_set |= JO_OUT_TIMEOUT;
3320 opt->jo_out_timeout = get_tv_number(item);
3321 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003322 else if (STRCMP(hi->hi_key, "err_timeout") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003323 {
3324 if (!(supported & JO_ERR_TIMEOUT))
3325 break;
3326 opt->jo_set |= JO_ERR_TIMEOUT;
3327 opt->jo_err_timeout = get_tv_number(item);
3328 }
3329 else if (STRCMP(hi->hi_key, "part") == 0)
3330 {
3331 if (!(supported & JO_PART))
3332 break;
3333 opt->jo_set |= JO_PART;
3334 val = get_tv_string(item);
3335 if (STRCMP(val, "err") == 0)
3336 opt->jo_part = PART_ERR;
3337 else
3338 {
3339 EMSG2(_(e_invarg2), val);
3340 return FAIL;
3341 }
3342 }
3343 else if (STRCMP(hi->hi_key, "id") == 0)
3344 {
3345 if (!(supported & JO_ID))
3346 break;
3347 opt->jo_set |= JO_ID;
3348 opt->jo_id = get_tv_number(item);
3349 }
3350 else if (STRCMP(hi->hi_key, "stoponexit") == 0)
3351 {
3352 if (!(supported & JO_STOPONEXIT))
3353 break;
3354 opt->jo_set |= JO_STOPONEXIT;
3355 opt->jo_stoponexit = get_tv_string_buf_chk(item,
3356 opt->jo_soe_buf);
3357 if (opt->jo_stoponexit == NULL)
3358 {
3359 EMSG2(_(e_invarg2), "stoponexit");
3360 return FAIL;
3361 }
3362 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003363 else if (STRCMP(hi->hi_key, "exit_cb") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003364 {
3365 if (!(supported & JO_EXIT_CB))
3366 break;
3367 opt->jo_set |= JO_EXIT_CB;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003368 if (item->v_type == VAR_PARTIAL && item->vval.v_partial != NULL)
3369 {
3370 opt->jo_exit_partial = item->vval.v_partial;
3371 opt->jo_exit_cb = item->vval.v_partial->pt_name;
3372 }
3373 else
3374 opt->jo_exit_cb = get_tv_string_buf_chk(
3375 item, opt->jo_ecb_buf);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003376 if (opt->jo_exit_cb == NULL)
3377 {
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003378 EMSG2(_(e_invarg2), "exit_cb");
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003379 return FAIL;
3380 }
3381 }
3382 else
3383 break;
3384 --todo;
3385 }
3386 if (todo > 0)
3387 {
3388 EMSG2(_(e_invarg2), hi->hi_key);
3389 return FAIL;
3390 }
3391
3392 return OK;
3393}
3394
3395/*
3396 * Get the channel from the argument.
3397 * Returns NULL if the handle is invalid.
3398 */
3399 channel_T *
3400get_channel_arg(typval_T *tv, int check_open)
3401{
3402 channel_T *channel = NULL;
3403
3404 if (tv->v_type == VAR_JOB)
3405 {
3406 if (tv->vval.v_job != NULL)
3407 channel = tv->vval.v_job->jv_channel;
3408 }
3409 else if (tv->v_type == VAR_CHANNEL)
3410 {
3411 channel = tv->vval.v_channel;
3412 }
3413 else
3414 {
3415 EMSG2(_(e_invarg2), get_tv_string(tv));
3416 return NULL;
3417 }
3418
3419 if (check_open && (channel == NULL || !channel_is_open(channel)))
3420 {
3421 EMSG(_("E906: not an open channel"));
3422 return NULL;
3423 }
3424 return channel;
3425}
3426
3427static job_T *first_job = NULL;
3428
3429 static void
3430job_free(job_T *job)
3431{
3432 ch_log(job->jv_channel, "Freeing job");
3433 if (job->jv_channel != NULL)
3434 {
3435 /* The link from the channel to the job doesn't count as a reference,
3436 * thus don't decrement the refcount of the job. The reference from
3437 * the job to the channel does count the refrence, decrement it and
3438 * NULL the reference. We don't set ch_job_killed, unreferencing the
3439 * job doesn't mean it stops running. */
3440 job->jv_channel->ch_job = NULL;
3441 channel_unref(job->jv_channel);
3442 }
3443 mch_clear_job(job);
3444
3445 if (job->jv_next != NULL)
3446 job->jv_next->jv_prev = job->jv_prev;
3447 if (job->jv_prev == NULL)
3448 first_job = job->jv_next;
3449 else
3450 job->jv_prev->jv_next = job->jv_next;
3451
3452 vim_free(job->jv_stoponexit);
3453 vim_free(job->jv_exit_cb);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003454 partial_unref(job->jv_exit_partial);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003455 vim_free(job);
3456}
3457
3458 void
3459job_unref(job_T *job)
3460{
3461 if (job != NULL && --job->jv_refcount <= 0)
3462 {
3463 /* Do not free the job when it has not ended yet and there is a
3464 * "stoponexit" flag or an exit callback. */
3465 if (job->jv_status != JOB_STARTED
3466 || (job->jv_stoponexit == NULL && job->jv_exit_cb == NULL))
3467 {
3468 job_free(job);
3469 }
3470 else if (job->jv_channel != NULL)
3471 {
3472 /* Do remove the link to the channel, otherwise it hangs
3473 * around until Vim exits. See job_free() for refcount. */
3474 job->jv_channel->ch_job = NULL;
3475 channel_unref(job->jv_channel);
3476 job->jv_channel = NULL;
3477 }
3478 }
3479}
3480
3481/*
3482 * Allocate a job. Sets the refcount to one and sets options default.
3483 */
3484 static job_T *
3485job_alloc(void)
3486{
3487 job_T *job;
3488
3489 job = (job_T *)alloc_clear(sizeof(job_T));
3490 if (job != NULL)
3491 {
3492 job->jv_refcount = 1;
3493 job->jv_stoponexit = vim_strsave((char_u *)"term");
3494
3495 if (first_job != NULL)
3496 {
3497 first_job->jv_prev = job;
3498 job->jv_next = first_job;
3499 }
3500 first_job = job;
3501 }
3502 return job;
3503}
3504
3505 void
3506job_set_options(job_T *job, jobopt_T *opt)
3507{
3508 if (opt->jo_set & JO_STOPONEXIT)
3509 {
3510 vim_free(job->jv_stoponexit);
3511 if (opt->jo_stoponexit == NULL || *opt->jo_stoponexit == NUL)
3512 job->jv_stoponexit = NULL;
3513 else
3514 job->jv_stoponexit = vim_strsave(opt->jo_stoponexit);
3515 }
3516 if (opt->jo_set & JO_EXIT_CB)
3517 {
3518 vim_free(job->jv_exit_cb);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003519 partial_unref(job->jv_exit_partial);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003520 if (opt->jo_exit_cb == NULL || *opt->jo_exit_cb == NUL)
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003521 {
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003522 job->jv_exit_cb = NULL;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003523 job->jv_exit_partial = NULL;
3524 }
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003525 else
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003526 {
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003527 job->jv_exit_cb = vim_strsave(opt->jo_exit_cb);
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003528 job->jv_exit_partial = opt->jo_exit_partial;
3529 if (job->jv_exit_partial != NULL)
3530 ++job->jv_exit_partial->pt_refcount;
3531 }
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003532 }
3533}
3534
3535/*
3536 * Called when Vim is exiting: kill all jobs that have the "stoponexit" flag.
3537 */
3538 void
3539job_stop_on_exit()
3540{
3541 job_T *job;
3542
3543 for (job = first_job; job != NULL; job = job->jv_next)
3544 if (job->jv_status == JOB_STARTED && job->jv_stoponexit != NULL)
3545 mch_stop_job(job, job->jv_stoponexit);
3546}
3547
3548/*
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003549 * Called once in a while: check if any jobs with an "exit_cb" have ended.
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003550 */
3551 void
3552job_check_ended(void)
3553{
3554 static time_t last_check = 0;
3555 time_t now;
3556 job_T *job;
3557 job_T *next;
3558
3559 /* Only do this once in 10 seconds. */
3560 now = time(NULL);
3561 if (last_check + 10 < now)
3562 {
3563 last_check = now;
3564 for (job = first_job; job != NULL; job = next)
3565 {
3566 next = job->jv_next;
3567 if (job->jv_status == JOB_STARTED && job->jv_exit_cb != NULL)
3568 job_status(job); /* may free "job" */
3569 }
3570 }
3571}
3572
3573/*
3574 * "job_start()" function
3575 */
3576 job_T *
3577job_start(typval_T *argvars)
3578{
3579 job_T *job;
3580 char_u *cmd = NULL;
3581#if defined(UNIX)
3582# define USE_ARGV
3583 char **argv = NULL;
3584 int argc = 0;
3585#else
3586 garray_T ga;
3587#endif
3588 jobopt_T opt;
3589 int part;
3590
3591 job = job_alloc();
3592 if (job == NULL)
3593 return NULL;
3594
3595 job->jv_status = JOB_FAILED;
3596
3597 /* Default mode is NL. */
3598 clear_job_options(&opt);
3599 opt.jo_mode = MODE_NL;
3600 if (get_job_options(&argvars[1], &opt,
3601 JO_MODE_ALL + JO_CB_ALL + JO_TIMEOUT_ALL
3602 + JO_STOPONEXIT + JO_EXIT_CB + JO_OUT_IO) == FAIL)
3603 return job;
3604
3605 /* Check that when io is "file" that there is a file name. */
3606 for (part = PART_OUT; part <= PART_IN; ++part)
3607 if ((opt.jo_set & (JO_OUT_IO << (part - PART_OUT)))
3608 && opt.jo_io[part] == JIO_FILE
3609 && (!(opt.jo_set & (JO_OUT_NAME << (part - PART_OUT)))
3610 || *opt.jo_io_name[part] == NUL))
3611 {
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003612 EMSG(_("E920: _io file requires _name to be set"));
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003613 return job;
3614 }
3615
3616 if ((opt.jo_set & JO_IN_IO) && opt.jo_io[PART_IN] == JIO_BUFFER)
3617 {
3618 buf_T *buf = NULL;
3619
3620 /* check that we can find the buffer before starting the job */
3621 if (opt.jo_set & JO_IN_BUF)
3622 {
3623 buf = buflist_findnr(opt.jo_io_buf[PART_IN]);
3624 if (buf == NULL)
3625 EMSGN(_(e_nobufnr), (long)opt.jo_io_buf[PART_IN]);
3626 }
3627 else if (!(opt.jo_set & JO_IN_NAME))
3628 {
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003629 EMSG(_("E915: in_io buffer requires in_buf or in_name to be set"));
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003630 }
3631 else
3632 buf = buflist_find_by_name(opt.jo_io_name[PART_IN], FALSE);
3633 if (buf == NULL)
3634 return job;
3635 if (buf->b_ml.ml_mfp == NULL)
3636 {
3637 char_u numbuf[NUMBUFLEN];
3638 char_u *s;
3639
3640 if (opt.jo_set & JO_IN_BUF)
3641 {
3642 sprintf((char *)numbuf, "%d", opt.jo_io_buf[PART_IN]);
3643 s = numbuf;
3644 }
3645 else
3646 s = opt.jo_io_name[PART_IN];
3647 EMSG2(_("E918: buffer must be loaded: %s"), s);
3648 return job;
3649 }
3650 job->jv_in_buf = buf;
3651 }
3652
3653 job_set_options(job, &opt);
3654
3655#ifndef USE_ARGV
3656 ga_init2(&ga, (int)sizeof(char*), 20);
3657#endif
3658
3659 if (argvars[0].v_type == VAR_STRING)
3660 {
3661 /* Command is a string. */
3662 cmd = argvars[0].vval.v_string;
3663#ifdef USE_ARGV
3664 if (mch_parse_cmd(cmd, FALSE, &argv, &argc) == FAIL)
3665 return job;
3666 argv[argc] = NULL;
3667#endif
3668 }
3669 else if (argvars[0].v_type != VAR_LIST
3670 || argvars[0].vval.v_list == NULL
3671 || argvars[0].vval.v_list->lv_len < 1)
3672 {
3673 EMSG(_(e_invarg));
3674 return job;
3675 }
3676 else
3677 {
3678 list_T *l = argvars[0].vval.v_list;
3679 listitem_T *li;
3680 char_u *s;
3681
3682#ifdef USE_ARGV
3683 /* Pass argv[] to mch_call_shell(). */
3684 argv = (char **)alloc(sizeof(char *) * (l->lv_len + 1));
3685 if (argv == NULL)
3686 return job;
3687#endif
3688 for (li = l->lv_first; li != NULL; li = li->li_next)
3689 {
3690 s = get_tv_string_chk(&li->li_tv);
3691 if (s == NULL)
3692 goto theend;
3693#ifdef USE_ARGV
3694 argv[argc++] = (char *)s;
3695#else
3696 /* Only escape when needed, double quotes are not always allowed. */
3697 if (li != l->lv_first && vim_strpbrk(s, (char_u *)" \t\"") != NULL)
3698 {
Bram Moolenaar583c1f12016-03-12 15:58:34 +01003699# ifdef WIN32
3700 int old_ssl = p_ssl;
3701
3702 /* This is using CreateProcess, not cmd.exe. Always use
3703 * double quote and backslashes. */
3704 p_ssl = 0;
3705# endif
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003706 s = vim_strsave_shellescape(s, FALSE, TRUE);
Bram Moolenaar583c1f12016-03-12 15:58:34 +01003707# ifdef WIN32
3708 p_ssl = old_ssl;
3709# endif
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003710 if (s == NULL)
3711 goto theend;
3712 ga_concat(&ga, s);
3713 vim_free(s);
3714 }
3715 else
3716 ga_concat(&ga, s);
3717 if (li->li_next != NULL)
3718 ga_append(&ga, ' ');
3719#endif
3720 }
3721#ifdef USE_ARGV
3722 argv[argc] = NULL;
3723#else
3724 cmd = ga.ga_data;
3725#endif
3726 }
3727
3728#ifdef USE_ARGV
3729 if (ch_log_active())
3730 {
3731 garray_T ga;
3732 int i;
3733
3734 ga_init2(&ga, (int)sizeof(char), 200);
3735 for (i = 0; i < argc; ++i)
3736 {
3737 if (i > 0)
3738 ga_concat(&ga, (char_u *)" ");
3739 ga_concat(&ga, (char_u *)argv[i]);
3740 }
3741 ch_logs(NULL, "Starting job: %s", (char *)ga.ga_data);
3742 ga_clear(&ga);
3743 }
3744 mch_start_job(argv, job, &opt);
3745#else
3746 ch_logs(NULL, "Starting job: %s", (char *)cmd);
3747 mch_start_job((char *)cmd, job, &opt);
3748#endif
3749
3750 /* If the channel is reading from a buffer, write lines now. */
3751 if (job->jv_channel != NULL)
3752 channel_write_in(job->jv_channel);
3753
3754theend:
3755#ifdef USE_ARGV
3756 vim_free(argv);
3757#else
3758 vim_free(ga.ga_data);
3759#endif
3760 return job;
3761}
3762
3763/*
3764 * Get the status of "job" and invoke the exit callback when needed.
3765 * The returned string is not allocated.
3766 */
3767 char *
3768job_status(job_T *job)
3769{
3770 char *result;
3771
3772 if (job->jv_status == JOB_ENDED)
3773 /* No need to check, dead is dead. */
3774 result = "dead";
3775 else if (job->jv_status == JOB_FAILED)
3776 result = "fail";
3777 else
3778 {
3779 result = mch_job_status(job);
3780 if (job->jv_status == JOB_ENDED)
3781 ch_log(job->jv_channel, "Job ended");
3782 if (job->jv_status == JOB_ENDED && job->jv_exit_cb != NULL)
3783 {
3784 typval_T argv[3];
3785 typval_T rettv;
3786 int dummy;
3787
3788 /* invoke the exit callback; make sure the refcount is > 0 */
3789 ++job->jv_refcount;
3790 argv[0].v_type = VAR_JOB;
3791 argv[0].vval.v_job = job;
3792 argv[1].v_type = VAR_NUMBER;
3793 argv[1].vval.v_number = job->jv_exitval;
3794 call_func(job->jv_exit_cb, (int)STRLEN(job->jv_exit_cb),
Bram Moolenaar1735bc92016-03-14 23:05:14 +01003795 &rettv, 2, argv, 0L, 0L, &dummy, TRUE,
3796 job->jv_exit_partial, NULL);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003797 clear_tv(&rettv);
3798 --job->jv_refcount;
3799 }
3800 if (job->jv_status == JOB_ENDED && job->jv_refcount == 0)
3801 {
3802 /* The job was already unreferenced, now that it ended it can be
3803 * freed. Careful: caller must not use "job" after this! */
3804 job_free(job);
3805 }
3806 }
3807 return result;
3808}
3809
Bram Moolenaar8950a562016-03-12 15:22:55 +01003810/*
3811 * Implementation of job_info().
3812 */
3813 void
3814job_info(job_T *job, dict_T *dict)
3815{
3816 dictitem_T *item;
3817 varnumber_T nr;
3818
3819 dict_add_nr_str(dict, "status", 0L, (char_u *)job_status(job));
3820
3821 item = dictitem_alloc((char_u *)"channel");
3822 if (item == NULL)
3823 return;
3824 item->di_tv.v_lock = 0;
3825 item->di_tv.v_type = VAR_CHANNEL;
3826 item->di_tv.vval.v_channel = job->jv_channel;
3827 if (job->jv_channel != NULL)
3828 ++job->jv_channel->ch_refcount;
3829 if (dict_add(dict, item) == FAIL)
3830 dictitem_free(item);
3831
3832#ifdef UNIX
3833 nr = job->jv_pid;
3834#else
3835 nr = job->jv_proc_info.dwProcessId;
3836#endif
3837 dict_add_nr_str(dict, "process", nr, NULL);
3838
3839 dict_add_nr_str(dict, "exitval", job->jv_exitval, NULL);
Bram Moolenaard6c2f052016-03-14 23:22:59 +01003840 dict_add_nr_str(dict, "exit_cb", 0L, job->jv_exit_cb);
Bram Moolenaar8950a562016-03-12 15:22:55 +01003841 dict_add_nr_str(dict, "stoponexit", 0L, job->jv_stoponexit);
3842}
3843
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003844 int
3845job_stop(job_T *job, typval_T *argvars)
3846{
3847 char_u *arg;
3848
3849 if (argvars[1].v_type == VAR_UNKNOWN)
3850 arg = (char_u *)"";
3851 else
3852 {
3853 arg = get_tv_string_chk(&argvars[1]);
3854 if (arg == NULL)
3855 {
3856 EMSG(_(e_invarg));
3857 return 0;
3858 }
3859 }
3860 ch_logs(job->jv_channel, "Stopping job with '%s'", (char *)arg);
3861 if (mch_stop_job(job, arg) == FAIL)
3862 return 0;
3863
3864 /* Assume that "hup" does not kill the job. */
3865 if (job->jv_channel != NULL && STRCMP(arg, "hup") != 0)
3866 job->jv_channel->ch_job_killed = TRUE;
3867
3868 /* We don't try freeing the job, obviously the caller still has a
3869 * reference to it. */
3870 return 1;
3871}
3872
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01003873#endif /* FEAT_JOB_CHANNEL */