blob: f20a4d851da353b7eeeb40d116d1d711a6cfe620 [file] [log] [blame]
Bram Moolenaaredf3f972016-08-29 22:49:24 +02001/* vi:set ts=8 sts=4 sw=4 noet:
Bram Moolenaare0874f82016-01-24 20:36:41 +01002 *
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
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +020013#ifdef WIN32
14// Must include winsock2.h before windows.h since it conflicts with winsock.h
15// (included in windows.h).
16# include <winsock2.h>
17# include <ws2tcpip.h>
18#endif
19
Bram Moolenaare0874f82016-01-24 20:36:41 +010020#include "vim.h"
21
Bram Moolenaar509ce2a2016-03-11 22:52:15 +010022#if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
Bram Moolenaare0874f82016-01-24 20:36:41 +010023
Bram Moolenaarc667da52019-11-30 20:52:27 +010024// TRUE when netbeans is running with a GUI.
Bram Moolenaard04a0202016-01-26 23:30:18 +010025#ifdef FEAT_GUI
26# define CH_HAS_GUI (gui.in_use || gui.starting)
27#endif
28
Bram Moolenaarc667da52019-11-30 20:52:27 +010029// Note: when making changes here also adjust configure.ac.
Bram Moolenaar4f974752019-02-17 17:44:42 +010030#ifdef MSWIN
Bram Moolenaarc667da52019-11-30 20:52:27 +010031// WinSock API is separated from C API, thus we can't use read(), write(),
32// errno...
Bram Moolenaard04a0202016-01-26 23:30:18 +010033# define SOCK_ERRNO errno = WSAGetLastError()
34# undef ECONNREFUSED
35# define ECONNREFUSED WSAECONNREFUSED
Bram Moolenaar4d919d72016-02-05 22:36:41 +010036# undef EWOULDBLOCK
37# define EWOULDBLOCK WSAEWOULDBLOCK
Bram Moolenaard42119f2016-02-28 20:51:49 +010038# undef EINPROGRESS
39# define EINPROGRESS WSAEINPROGRESS
Bram Moolenaard04a0202016-01-26 23:30:18 +010040# ifdef EINTR
41# undef EINTR
42# endif
43# define EINTR WSAEINTR
Bram Moolenaard8070362016-02-15 21:56:54 +010044# define sock_write(sd, buf, len) send((SOCKET)sd, buf, len, 0)
45# define sock_read(sd, buf, len) recv((SOCKET)sd, buf, len, 0)
46# define sock_close(sd) closesocket((SOCKET)sd)
Bram Moolenaard04a0202016-01-26 23:30:18 +010047#else
48# include <netdb.h>
49# include <netinet/in.h>
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +020050# include <arpa/inet.h>
Bram Moolenaard04a0202016-01-26 23:30:18 +010051# include <sys/socket.h>
52# ifdef HAVE_LIBGEN_H
53# include <libgen.h>
54# endif
55# define SOCK_ERRNO
56# define sock_write(sd, buf, len) write(sd, buf, len)
57# define sock_read(sd, buf, len) read(sd, buf, len)
58# define sock_close(sd) close(sd)
Bram Moolenaar0943a092016-02-16 13:11:17 +010059# define fd_read(fd, buf, len) read(fd, buf, len)
Bram Moolenaard8070362016-02-15 21:56:54 +010060# define fd_write(sd, buf, len) write(sd, buf, len)
61# define fd_close(sd) close(sd)
Bram Moolenaard04a0202016-01-26 23:30:18 +010062#endif
63
Bram Moolenaardc0ccae2016-10-09 17:28:01 +020064static void channel_read(channel_T *channel, ch_part_T part, char *func);
Bram Moolenaar5843f5f2019-08-20 20:13:45 +020065static ch_mode_T channel_get_mode(channel_T *channel, ch_part_T part);
66static int channel_get_timeout(channel_T *channel, ch_part_T part);
67static ch_part_T channel_part_send(channel_T *channel);
68static ch_part_T channel_part_read(channel_T *channel);
69static void free_job_options(jobopt_T *opt);
Bram Moolenaarb2658a12016-04-26 17:16:24 +020070
Bram Moolenaaraeea7212020-04-02 18:50:46 +020071#define FOR_ALL_CHANNELS(ch) \
72 for ((ch) = first_channel; (ch) != NULL; (ch) = (ch)->ch_next)
73
74#define FOR_ALL_JOBS(job) \
75 for ((job) = first_job; (job) != NULL; (job) = (job)->jv_next)
76
Bram Moolenaarc667da52019-11-30 20:52:27 +010077// Whether a redraw is needed for appending a line to a buffer.
Bram Moolenaar187db502016-02-27 14:44:26 +010078static int channel_need_redraw = FALSE;
79
Bram Moolenaarc667da52019-11-30 20:52:27 +010080// Whether we are inside channel_parse_messages() or another situation where it
81// is safe to invoke callbacks.
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +020082static int safe_to_invoke_callback = 0;
Bram Moolenaar187db502016-02-27 14:44:26 +010083
Bram Moolenaarde7eb0a2016-05-09 20:54:33 +020084static char *part_names[] = {"sock", "out", "err", "in"};
85
Bram Moolenaar4f974752019-02-17 17:44:42 +010086#ifdef MSWIN
Bram Moolenaard8070362016-02-15 21:56:54 +010087 static int
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +010088fd_read(sock_T fd, char *buf, size_t len)
Bram Moolenaard8070362016-02-15 21:56:54 +010089{
90 HANDLE h = (HANDLE)fd;
91 DWORD nread;
92
93 if (!ReadFile(h, buf, (DWORD)len, &nread, NULL))
94 return -1;
95 return (int)nread;
96}
97
98 static int
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +010099fd_write(sock_T fd, char *buf, size_t len)
Bram Moolenaard8070362016-02-15 21:56:54 +0100100{
Bram Moolenaar24058382019-01-24 23:11:49 +0100101 size_t todo = len;
Bram Moolenaarb091f302019-01-19 14:37:00 +0100102 HANDLE h = (HANDLE)fd;
Bram Moolenaar24058382019-01-24 23:11:49 +0100103 DWORD nwrite, size, done = 0;
Bram Moolenaarb091f302019-01-19 14:37:00 +0100104 OVERLAPPED ov;
Bram Moolenaard8070362016-02-15 21:56:54 +0100105
Bram Moolenaar24058382019-01-24 23:11:49 +0100106 while (todo > 0)
Bram Moolenaarb091f302019-01-19 14:37:00 +0100107 {
Bram Moolenaar24058382019-01-24 23:11:49 +0100108 if (todo > MAX_NAMED_PIPE_SIZE)
109 size = MAX_NAMED_PIPE_SIZE;
110 else
Bram Moolenaardec01202019-01-28 20:04:24 +0100111 size = (DWORD)todo;
Bram Moolenaar65240682019-02-10 22:23:26 +0100112 // If the pipe overflows while the job does not read the data,
113 // WriteFile() will block forever. This abandons the write.
Bram Moolenaar24058382019-01-24 23:11:49 +0100114 memset(&ov, 0, sizeof(ov));
Bram Moolenaar65240682019-02-10 22:23:26 +0100115 nwrite = 0;
Bram Moolenaar24058382019-01-24 23:11:49 +0100116 if (!WriteFile(h, buf + done, size, &nwrite, &ov))
117 {
118 DWORD err = GetLastError();
Bram Moolenaarb091f302019-01-19 14:37:00 +0100119
Bram Moolenaar24058382019-01-24 23:11:49 +0100120 if (err != ERROR_IO_PENDING)
121 return -1;
122 if (!GetOverlappedResult(h, &ov, &nwrite, FALSE))
123 return -1;
124 FlushFileBuffers(h);
125 }
Bram Moolenaar65240682019-02-10 22:23:26 +0100126 else if (nwrite == 0)
127 // WriteFile() returns TRUE but did not write anything. This causes
128 // a hang, so bail out.
129 break;
Bram Moolenaar24058382019-01-24 23:11:49 +0100130 todo -= nwrite;
131 done += nwrite;
Bram Moolenaarb091f302019-01-19 14:37:00 +0100132 }
Bram Moolenaar24058382019-01-24 23:11:49 +0100133 return (int)done;
Bram Moolenaard8070362016-02-15 21:56:54 +0100134}
135
136 static void
137fd_close(sock_T fd)
138{
139 HANDLE h = (HANDLE)fd;
140
141 CloseHandle(h);
142}
143#endif
Bram Moolenaare0874f82016-01-24 20:36:41 +0100144
Bram Moolenaarc667da52019-11-30 20:52:27 +0100145// Log file opened with ch_logfile().
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100146static FILE *log_fd = NULL;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100147#ifdef FEAT_RELTIME
148static proftime_T log_start;
149#endif
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100150
151 void
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100152ch_logfile(char_u *fname, char_u *opt)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100153{
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100154 FILE *file = NULL;
155
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100156 if (log_fd != NULL)
Bram Moolenaar2e47cab2019-09-27 23:12:45 +0200157 {
158 if (*fname != NUL)
Bram Moolenaar03a9f842020-05-13 13:40:16 +0200159 ch_log(NULL, "closing this logfile, opening %s", fname);
Bram Moolenaar2e47cab2019-09-27 23:12:45 +0200160 else
Bram Moolenaar03a9f842020-05-13 13:40:16 +0200161 ch_log(NULL, "closing logfile");
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100162 fclose(log_fd);
Bram Moolenaar2e47cab2019-09-27 23:12:45 +0200163 }
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100164
165 if (*fname != NUL)
166 {
167 file = fopen((char *)fname, *opt == 'w' ? "w" : "a");
168 if (file == NULL)
169 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100170 semsg(_(e_notopen), fname);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100171 return;
172 }
173 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100174 log_fd = file;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100175
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100176 if (log_fd != NULL)
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100177 {
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100178 fprintf(log_fd, "==== start log session ====\n");
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100179#ifdef FEAT_RELTIME
180 profile_start(&log_start);
181#endif
182 }
183}
184
185 int
Bram Moolenaarcf089462016-06-12 21:18:43 +0200186ch_log_active(void)
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100187{
188 return log_fd != NULL;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100189}
190
191 static void
Bram Moolenaar4b16ee72018-08-09 22:15:34 +0200192ch_log_lead(const char *what, channel_T *ch, ch_part_T part)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100193{
194 if (log_fd != NULL)
195 {
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100196#ifdef FEAT_RELTIME
197 proftime_T log_now;
198
199 profile_start(&log_now);
200 profile_sub(&log_now, &log_start);
201 fprintf(log_fd, "%s ", profile_msg(&log_now));
202#endif
Bram Moolenaar77073442016-02-13 23:23:53 +0100203 if (ch != NULL)
Bram Moolenaar4b16ee72018-08-09 22:15:34 +0200204 {
205 if (part < PART_COUNT)
206 fprintf(log_fd, "%son %d(%s): ",
207 what, ch->ch_id, part_names[part]);
208 else
209 fprintf(log_fd, "%son %d: ", what, ch->ch_id);
210 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100211 else
212 fprintf(log_fd, "%s: ", what);
213 }
214}
215
Bram Moolenaar8caa43d2019-02-20 22:45:06 +0100216#ifndef PROTO // prototype is in proto.h
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100217 void
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200218ch_log(channel_T *ch, const char *fmt, ...)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100219{
220 if (log_fd != NULL)
221 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200222 va_list ap;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100223
Bram Moolenaar4b16ee72018-08-09 22:15:34 +0200224 ch_log_lead("", ch, PART_COUNT);
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200225 va_start(ap, fmt);
226 vfprintf(log_fd, fmt, ap);
227 va_end(ap);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100228 fputc('\n', log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100229 fflush(log_fd);
Bram Moolenaar101e9922019-09-25 21:43:11 +0200230 did_repeated_msg = 0;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100231 }
232}
Bram Moolenaar4ac2e8d2018-04-08 12:38:26 +0200233#endif
234
235 static void
236ch_error(channel_T *ch, const char *fmt, ...)
Bram Moolenaare80757c2018-04-10 12:42:44 +0200237#ifdef USE_PRINTF_FORMAT_ATTRIBUTE
238 __attribute__((format(printf, 2, 3)))
Bram Moolenaar4ac2e8d2018-04-08 12:38:26 +0200239#endif
240 ;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100241
242 static void
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200243ch_error(channel_T *ch, const char *fmt, ...)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100244{
245 if (log_fd != NULL)
246 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200247 va_list ap;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100248
Bram Moolenaar4b16ee72018-08-09 22:15:34 +0200249 ch_log_lead("ERR ", ch, PART_COUNT);
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200250 va_start(ap, fmt);
251 vfprintf(log_fd, fmt, ap);
252 va_end(ap);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100253 fputc('\n', log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100254 fflush(log_fd);
Bram Moolenaar101e9922019-09-25 21:43:11 +0200255 did_repeated_msg = 0;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100256 }
257}
Bram Moolenaard04a0202016-01-26 23:30:18 +0100258
Bram Moolenaar4f974752019-02-17 17:44:42 +0100259#ifdef MSWIN
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100260# undef PERROR
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100261# define PERROR(msg) (void)semsg("%s: %s", msg, strerror_win32(errno))
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100262
263 static char *
264strerror_win32(int eno)
265{
266 static LPVOID msgbuf = NULL;
267 char_u *ptr;
268
269 if (msgbuf)
Bram Moolenaaraad30bb2016-06-26 17:31:03 +0200270 {
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100271 LocalFree(msgbuf);
Bram Moolenaaraad30bb2016-06-26 17:31:03 +0200272 msgbuf = NULL;
273 }
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100274 FormatMessage(
275 FORMAT_MESSAGE_ALLOCATE_BUFFER |
276 FORMAT_MESSAGE_FROM_SYSTEM |
277 FORMAT_MESSAGE_IGNORE_INSERTS,
278 NULL,
279 eno,
280 MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),
281 (LPTSTR) &msgbuf,
282 0,
283 NULL);
Bram Moolenaaraad30bb2016-06-26 17:31:03 +0200284 if (msgbuf != NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100285 // chomp \r or \n
Bram Moolenaaraad30bb2016-06-26 17:31:03 +0200286 for (ptr = (char_u *)msgbuf; *ptr; ptr++)
287 switch (*ptr)
288 {
289 case '\r':
290 STRMOVE(ptr, ptr + 1);
291 ptr--;
292 break;
293 case '\n':
294 if (*(ptr + 1) == '\0')
295 *ptr = '\0';
296 else
297 *ptr = ' ';
298 break;
299 }
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100300 return msgbuf;
301}
302#endif
303
Bram Moolenaar77073442016-02-13 23:23:53 +0100304/*
305 * The list of all allocated channels.
306 */
307static channel_T *first_channel = NULL;
308static int next_ch_id = 0;
309
310/*
311 * Allocate a new channel. The refcount is set to 1.
312 * The channel isn't actually used until it is opened.
313 * Returns NULL if out of memory.
314 */
315 channel_T *
316add_channel(void)
Bram Moolenaare0874f82016-01-24 20:36:41 +0100317{
Bram Moolenaardc0ccae2016-10-09 17:28:01 +0200318 ch_part_T part;
Bram Moolenaarc799fe22019-05-28 23:08:19 +0200319 channel_T *channel = ALLOC_CLEAR_ONE(channel_T);
Bram Moolenaare0874f82016-01-24 20:36:41 +0100320
Bram Moolenaar77073442016-02-13 23:23:53 +0100321 if (channel == NULL)
322 return NULL;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100323
Bram Moolenaar77073442016-02-13 23:23:53 +0100324 channel->ch_id = next_ch_id++;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100325 ch_log(channel, "Created channel");
Bram Moolenaar77073442016-02-13 23:23:53 +0100326
Bram Moolenaardc0ccae2016-10-09 17:28:01 +0200327 for (part = PART_SOCK; part < PART_COUNT; ++part)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100328 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100329 channel->ch_part[part].ch_fd = INVALID_FD;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100330#ifdef FEAT_GUI_X11
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100331 channel->ch_part[part].ch_inputHandler = (XtInputId)NULL;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100332#endif
333#ifdef FEAT_GUI_GTK
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100334 channel->ch_part[part].ch_inputHandler = 0;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100335#endif
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100336 channel->ch_part[part].ch_timeout = 2000;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100337 }
Bram Moolenaare0874f82016-01-24 20:36:41 +0100338
Bram Moolenaar77073442016-02-13 23:23:53 +0100339 if (first_channel != NULL)
340 {
341 first_channel->ch_prev = channel;
342 channel->ch_next = first_channel;
343 }
344 first_channel = channel;
345
346 channel->ch_refcount = 1;
347 return channel;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100348}
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100349
Bram Moolenaarb9c31e72016-09-29 15:18:57 +0200350 int
351has_any_channel(void)
352{
353 return first_channel != NULL;
354}
355
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100356/*
Bram Moolenaard6051b52016-02-28 15:49:03 +0100357 * Called when the refcount of a channel is zero.
Bram Moolenaar46c85432016-02-26 11:17:46 +0100358 * Return TRUE if "channel" has a callback and the associated job wasn't
359 * killed.
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100360 */
361 static int
Bram Moolenaar46c85432016-02-26 11:17:46 +0100362channel_still_useful(channel_T *channel)
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100363{
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100364 int has_sock_msg;
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100365 int has_out_msg;
366 int has_err_msg;
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100367
Bram Moolenaarc667da52019-11-30 20:52:27 +0100368 // If the job was killed the channel is not expected to work anymore.
Bram Moolenaar46c85432016-02-26 11:17:46 +0100369 if (channel->ch_job_killed && channel->ch_job == NULL)
370 return FALSE;
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100371
Bram Moolenaarc667da52019-11-30 20:52:27 +0100372 // If there is a close callback it may still need to be invoked.
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200373 if (channel->ch_close_cb.cb_name != NULL)
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100374 return TRUE;
375
Bram Moolenaarc667da52019-11-30 20:52:27 +0100376 // If reading from or a buffer it's still useful.
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +0200377 if (channel->ch_part[PART_IN].ch_bufref.br_buf != NULL)
Bram Moolenaar5d96e3a2016-05-08 21:47:01 +0200378 return TRUE;
379
Bram Moolenaarc667da52019-11-30 20:52:27 +0100380 // If there is no callback then nobody can get readahead. If the fd is
381 // closed and there is no readahead then the callback won't be called.
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100382 has_sock_msg = channel->ch_part[PART_SOCK].ch_fd != INVALID_FD
Bram Moolenaard23a8232018-02-10 18:45:26 +0100383 || channel->ch_part[PART_SOCK].ch_head.rq_next != NULL
384 || channel->ch_part[PART_SOCK].ch_json_head.jq_next != NULL;
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100385 has_out_msg = channel->ch_part[PART_OUT].ch_fd != INVALID_FD
386 || channel->ch_part[PART_OUT].ch_head.rq_next != NULL
387 || channel->ch_part[PART_OUT].ch_json_head.jq_next != NULL;
388 has_err_msg = channel->ch_part[PART_ERR].ch_fd != INVALID_FD
389 || channel->ch_part[PART_ERR].ch_head.rq_next != NULL
390 || channel->ch_part[PART_ERR].ch_json_head.jq_next != NULL;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200391 return (channel->ch_callback.cb_name != NULL && (has_sock_msg
Bram Moolenaar509ce2a2016-03-11 22:52:15 +0100392 || has_out_msg || has_err_msg))
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200393 || ((channel->ch_part[PART_OUT].ch_callback.cb_name != NULL
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +0200394 || channel->ch_part[PART_OUT].ch_bufref.br_buf != NULL)
395 && has_out_msg)
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200396 || ((channel->ch_part[PART_ERR].ch_callback.cb_name != NULL
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +0200397 || channel->ch_part[PART_ERR].ch_bufref.br_buf != NULL)
398 && has_err_msg);
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100399}
400
401/*
Bram Moolenaar4e9d4432018-04-24 20:54:07 +0200402 * Return TRUE if "channel" is closeable (i.e. all readable fds are closed).
403 */
404 static int
405channel_can_close(channel_T *channel)
406{
407 return channel->ch_to_be_closed == 0;
408}
409
410/*
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200411 * Close a channel and free all its resources.
Bram Moolenaar71658f72020-03-24 20:35:19 +0100412 * The "channel" pointer remains valid.
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200413 */
414 static void
415channel_free_contents(channel_T *channel)
416{
417 channel_close(channel, TRUE);
418 channel_clear(channel);
419 ch_log(channel, "Freeing channel");
420}
421
Bram Moolenaar71658f72020-03-24 20:35:19 +0100422/*
423 * Unlink "channel" from the list of channels and free it.
424 */
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200425 static void
426channel_free_channel(channel_T *channel)
427{
428 if (channel->ch_next != NULL)
429 channel->ch_next->ch_prev = channel->ch_prev;
430 if (channel->ch_prev == NULL)
431 first_channel = channel->ch_next;
432 else
433 channel->ch_prev->ch_next = channel->ch_next;
434 vim_free(channel);
435}
436
437 static void
438channel_free(channel_T *channel)
439{
440 if (!in_free_unref_items)
441 {
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +0200442 if (safe_to_invoke_callback == 0)
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +0200443 channel->ch_to_be_freed = TRUE;
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +0200444 else
445 {
446 channel_free_contents(channel);
447 channel_free_channel(channel);
448 }
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200449 }
450}
451
452/*
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100453 * Close a channel and free all its resources if there is no further action
Bram Moolenaar46c85432016-02-26 11:17:46 +0100454 * possible, there is no callback to be invoked or the associated job was
455 * killed.
Bram Moolenaar70765942016-02-28 19:28:59 +0100456 * Return TRUE if the channel was freed.
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100457 */
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100458 static int
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100459channel_may_free(channel_T *channel)
460{
Bram Moolenaar46c85432016-02-26 11:17:46 +0100461 if (!channel_still_useful(channel))
Bram Moolenaar70765942016-02-28 19:28:59 +0100462 {
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100463 channel_free(channel);
Bram Moolenaar70765942016-02-28 19:28:59 +0100464 return TRUE;
465 }
466 return FALSE;
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100467}
468
469/*
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100470 * Decrement the reference count on "channel" and maybe free it when it goes
471 * down to zero. Don't free it if there is a pending action.
472 * Returns TRUE when the channel is no longer referenced.
473 */
474 int
475channel_unref(channel_T *channel)
476{
477 if (channel != NULL && --channel->ch_refcount <= 0)
478 return channel_may_free(channel);
479 return FALSE;
480}
481
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200482 int
483free_unused_channels_contents(int copyID, int mask)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100484{
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200485 int did_free = FALSE;
486 channel_T *ch;
487
Bram Moolenaarc667da52019-11-30 20:52:27 +0100488 // This is invoked from the garbage collector, which only runs at a safe
489 // point.
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +0200490 ++safe_to_invoke_callback;
491
Bram Moolenaaraeea7212020-04-02 18:50:46 +0200492 FOR_ALL_CHANNELS(ch)
Bram Moolenaar674127e2016-04-26 20:30:07 +0200493 if (!channel_still_useful(ch)
494 && (ch->ch_copyID & mask) != (copyID & mask))
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200495 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100496 // Free the channel and ordinary items it contains, but don't
497 // recurse into Lists, Dictionaries etc.
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200498 channel_free_contents(ch);
499 did_free = TRUE;
500 }
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +0200501
502 --safe_to_invoke_callback;
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200503 return did_free;
504}
505
506 void
507free_unused_channels(int copyID, int mask)
508{
509 channel_T *ch;
510 channel_T *ch_next;
511
512 for (ch = first_channel; ch != NULL; ch = ch_next)
513 {
514 ch_next = ch->ch_next;
Bram Moolenaar674127e2016-04-26 20:30:07 +0200515 if (!channel_still_useful(ch)
516 && (ch->ch_copyID & mask) != (copyID & mask))
Bram Moolenaarc667da52019-11-30 20:52:27 +0100517 // Free the channel struct itself.
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200518 channel_free_channel(ch);
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200519 }
Bram Moolenaare0874f82016-01-24 20:36:41 +0100520}
521
Bram Moolenaard04a0202016-01-26 23:30:18 +0100522#if defined(FEAT_GUI) || defined(PROTO)
Bram Moolenaar77073442016-02-13 23:23:53 +0100523
Bram Moolenaarea781452019-09-04 18:53:12 +0200524# if defined(FEAT_GUI_X11) || defined(FEAT_GUI_GTK)
525/*
526 * Lookup the channel from the socket. Set "partp" to the fd index.
527 * Returns NULL when the socket isn't found.
528 */
529 static channel_T *
530channel_fd2channel(sock_T fd, ch_part_T *partp)
531{
532 channel_T *channel;
533 ch_part_T part;
534
535 if (fd != INVALID_FD)
Bram Moolenaaraeea7212020-04-02 18:50:46 +0200536 FOR_ALL_CHANNELS(channel)
Bram Moolenaarea781452019-09-04 18:53:12 +0200537 {
538 for (part = PART_SOCK; part < PART_IN; ++part)
539 if (channel->ch_part[part].ch_fd == fd)
540 {
541 *partp = part;
542 return channel;
543 }
544 }
545 return NULL;
546}
547
Bram Moolenaar77073442016-02-13 23:23:53 +0100548 static void
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100549channel_read_fd(int fd)
Bram Moolenaar77073442016-02-13 23:23:53 +0100550{
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100551 channel_T *channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +0200552 ch_part_T part;
Bram Moolenaar77073442016-02-13 23:23:53 +0100553
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100554 channel = channel_fd2channel(fd, &part);
Bram Moolenaar77073442016-02-13 23:23:53 +0100555 if (channel == NULL)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200556 ch_error(NULL, "Channel for fd %d not found", fd);
Bram Moolenaar77073442016-02-13 23:23:53 +0100557 else
Bram Moolenaarf8df45d2016-05-25 21:48:13 +0200558 channel_read(channel, part, "channel_read_fd");
Bram Moolenaar77073442016-02-13 23:23:53 +0100559}
Bram Moolenaarea781452019-09-04 18:53:12 +0200560# endif
Bram Moolenaar77073442016-02-13 23:23:53 +0100561
Bram Moolenaare0874f82016-01-24 20:36:41 +0100562/*
Bram Moolenaard04a0202016-01-26 23:30:18 +0100563 * Read a command from netbeans.
Bram Moolenaare0874f82016-01-24 20:36:41 +0100564 */
Bram Moolenaarea781452019-09-04 18:53:12 +0200565# ifdef FEAT_GUI_X11
Bram Moolenaard04a0202016-01-26 23:30:18 +0100566 static void
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200567messageFromServerX11(XtPointer clientData,
Bram Moolenaarf8df45d2016-05-25 21:48:13 +0200568 int *unused1 UNUSED,
569 XtInputId *unused2 UNUSED)
Bram Moolenaare0874f82016-01-24 20:36:41 +0100570{
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100571 channel_read_fd((int)(long)clientData);
Bram Moolenaare0874f82016-01-24 20:36:41 +0100572}
Bram Moolenaarea781452019-09-04 18:53:12 +0200573# endif
Bram Moolenaare0874f82016-01-24 20:36:41 +0100574
Bram Moolenaarea781452019-09-04 18:53:12 +0200575# ifdef FEAT_GUI_GTK
576# if GTK_CHECK_VERSION(3,0,0)
Bram Moolenaar98921892016-02-23 17:14:37 +0100577 static gboolean
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200578messageFromServerGtk3(GIOChannel *unused1 UNUSED,
Bram Moolenaarf8df45d2016-05-25 21:48:13 +0200579 GIOCondition unused2 UNUSED,
580 gpointer clientData)
Bram Moolenaar98921892016-02-23 17:14:37 +0100581{
582 channel_read_fd(GPOINTER_TO_INT(clientData));
Bram Moolenaarc667da52019-11-30 20:52:27 +0100583 return TRUE; // Return FALSE instead in case the event source is to
584 // be removed after this function returns.
Bram Moolenaar98921892016-02-23 17:14:37 +0100585}
Bram Moolenaarea781452019-09-04 18:53:12 +0200586# else
Bram Moolenaard04a0202016-01-26 23:30:18 +0100587 static void
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200588messageFromServerGtk2(gpointer clientData,
Bram Moolenaarf8df45d2016-05-25 21:48:13 +0200589 gint unused1 UNUSED,
590 GdkInputCondition unused2 UNUSED)
Bram Moolenaare0874f82016-01-24 20:36:41 +0100591{
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100592 channel_read_fd((int)(long)clientData);
Bram Moolenaare0874f82016-01-24 20:36:41 +0100593}
Bram Moolenaarea781452019-09-04 18:53:12 +0200594# endif
Bram Moolenaar98921892016-02-23 17:14:37 +0100595# endif
Bram Moolenaare0874f82016-01-24 20:36:41 +0100596
597 static void
Bram Moolenaarbd67aac2019-09-21 23:09:04 +0200598channel_gui_register_one(channel_T *channel, ch_part_T part UNUSED)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100599{
Bram Moolenaarde279892016-03-11 22:19:44 +0100600 if (!CH_HAS_GUI)
601 return;
602
Bram Moolenaarc667da52019-11-30 20:52:27 +0100603 // gets stuck in handling events for a not connected channel
Bram Moolenaar13ebb032017-08-26 22:02:51 +0200604 if (channel->ch_keep_open)
605 return;
606
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100607# ifdef FEAT_GUI_X11
Bram Moolenaarc667da52019-11-30 20:52:27 +0100608 // Tell notifier we are interested in being called when there is input on
609 // the editor connection socket.
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100610 if (channel->ch_part[part].ch_inputHandler == (XtInputId)NULL)
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200611 {
612 ch_log(channel, "Registering part %s with fd %d",
613 part_names[part], channel->ch_part[part].ch_fd);
614
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100615 channel->ch_part[part].ch_inputHandler = XtAppAddInput(
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100616 (XtAppContext)app_context,
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100617 channel->ch_part[part].ch_fd,
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100618 (XtPointer)(XtInputReadMask + XtInputExceptMask),
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200619 messageFromServerX11,
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100620 (XtPointer)(long)channel->ch_part[part].ch_fd);
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200621 }
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100622# else
623# ifdef FEAT_GUI_GTK
Bram Moolenaarc667da52019-11-30 20:52:27 +0100624 // Tell gdk we are interested in being called when there is input on the
625 // editor connection socket.
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100626 if (channel->ch_part[part].ch_inputHandler == 0)
Bram Moolenaar98921892016-02-23 17:14:37 +0100627 {
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200628 ch_log(channel, "Registering part %s with fd %d",
629 part_names[part], channel->ch_part[part].ch_fd);
630# if GTK_CHECK_VERSION(3,0,0)
Bram Moolenaar98921892016-02-23 17:14:37 +0100631 GIOChannel *chnnl = g_io_channel_unix_new(
632 (gint)channel->ch_part[part].ch_fd);
633
634 channel->ch_part[part].ch_inputHandler = g_io_add_watch(
635 chnnl,
636 G_IO_IN|G_IO_HUP|G_IO_ERR|G_IO_PRI,
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200637 messageFromServerGtk3,
Bram Moolenaar98921892016-02-23 17:14:37 +0100638 GINT_TO_POINTER(channel->ch_part[part].ch_fd));
639
640 g_io_channel_unref(chnnl);
Bram Moolenaar98921892016-02-23 17:14:37 +0100641# else
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100642 channel->ch_part[part].ch_inputHandler = gdk_input_add(
643 (gint)channel->ch_part[part].ch_fd,
Bram Moolenaar16eb4f82016-02-14 23:02:34 +0100644 (GdkInputCondition)
645 ((int)GDK_INPUT_READ + (int)GDK_INPUT_EXCEPTION),
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200646 messageFromServerGtk2,
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100647 (gpointer)(long)channel->ch_part[part].ch_fd);
Bram Moolenaar98921892016-02-23 17:14:37 +0100648# endif
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200649 }
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100650# endif
651# endif
652}
653
Bram Moolenaarde279892016-03-11 22:19:44 +0100654 static void
Bram Moolenaar77073442016-02-13 23:23:53 +0100655channel_gui_register(channel_T *channel)
Bram Moolenaare0874f82016-01-24 20:36:41 +0100656{
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100657 if (channel->CH_SOCK_FD != INVALID_FD)
658 channel_gui_register_one(channel, PART_SOCK);
Bram Moolenaar13ebb032017-08-26 22:02:51 +0200659 if (channel->CH_OUT_FD != INVALID_FD
660 && channel->CH_OUT_FD != channel->CH_SOCK_FD)
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100661 channel_gui_register_one(channel, PART_OUT);
Bram Moolenaar13ebb032017-08-26 22:02:51 +0200662 if (channel->CH_ERR_FD != INVALID_FD
663 && channel->CH_ERR_FD != channel->CH_SOCK_FD
664 && channel->CH_ERR_FD != channel->CH_OUT_FD)
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100665 channel_gui_register_one(channel, PART_ERR);
Bram Moolenaard04a0202016-01-26 23:30:18 +0100666}
667
668/*
669 * Register any of our file descriptors with the GUI event handling system.
670 * Called when the GUI has started.
671 */
672 void
673channel_gui_register_all(void)
674{
Bram Moolenaar77073442016-02-13 23:23:53 +0100675 channel_T *channel;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100676
Bram Moolenaaraeea7212020-04-02 18:50:46 +0200677 FOR_ALL_CHANNELS(channel)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100678 channel_gui_register(channel);
679}
680
681 static void
Bram Moolenaarbd67aac2019-09-21 23:09:04 +0200682channel_gui_unregister_one(channel_T *channel UNUSED, ch_part_T part UNUSED)
Bram Moolenaarde279892016-03-11 22:19:44 +0100683{
684# ifdef FEAT_GUI_X11
685 if (channel->ch_part[part].ch_inputHandler != (XtInputId)NULL)
686 {
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200687 ch_log(channel, "Unregistering part %s", part_names[part]);
Bram Moolenaarde279892016-03-11 22:19:44 +0100688 XtRemoveInput(channel->ch_part[part].ch_inputHandler);
689 channel->ch_part[part].ch_inputHandler = (XtInputId)NULL;
690 }
691# else
692# ifdef FEAT_GUI_GTK
693 if (channel->ch_part[part].ch_inputHandler != 0)
694 {
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200695 ch_log(channel, "Unregistering part %s", part_names[part]);
Bram Moolenaarde279892016-03-11 22:19:44 +0100696# if GTK_CHECK_VERSION(3,0,0)
697 g_source_remove(channel->ch_part[part].ch_inputHandler);
698# else
699 gdk_input_remove(channel->ch_part[part].ch_inputHandler);
700# endif
701 channel->ch_part[part].ch_inputHandler = 0;
702 }
703# endif
704# endif
705}
706
707 static void
Bram Moolenaar16eb4f82016-02-14 23:02:34 +0100708channel_gui_unregister(channel_T *channel)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100709{
Bram Moolenaardc0ccae2016-10-09 17:28:01 +0200710 ch_part_T part;
Bram Moolenaar16eb4f82016-02-14 23:02:34 +0100711
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100712 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaarde279892016-03-11 22:19:44 +0100713 channel_gui_unregister_one(channel, part);
Bram Moolenaard04a0202016-01-26 23:30:18 +0100714}
715
Bram Moolenaarea781452019-09-04 18:53:12 +0200716#endif // FEAT_GUI
Bram Moolenaard04a0202016-01-26 23:30:18 +0100717
Bram Moolenaare74e8e72016-02-16 22:01:30 +0100718static char *e_cannot_connect = N_("E902: Cannot connect to port");
719
Bram Moolenaard04a0202016-01-26 23:30:18 +0100720/*
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200721 * For Unix we need to call connect() again after connect() failed.
722 * On Win32 one time is sufficient.
Bram Moolenaard04a0202016-01-26 23:30:18 +0100723 */
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200724 static int
725channel_connect(
726 channel_T *channel,
727 const struct sockaddr *server_addr,
728 int server_addrlen,
729 int *waittime)
Bram Moolenaard04a0202016-01-26 23:30:18 +0100730{
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200731 int sd = -1;
Bram Moolenaar4f974752019-02-17 17:44:42 +0100732#ifdef MSWIN
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200733 u_long val = 1;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100734#endif
735
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100736 while (TRUE)
737 {
Bram Moolenaar562ca712016-03-09 21:50:05 +0100738 long elapsed_msec = 0;
739 int waitnow;
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200740 int ret;
Bram Moolenaar045a2842016-03-08 22:33:07 +0100741
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100742 if (sd >= 0)
Bram Moolenaard04a0202016-01-26 23:30:18 +0100743 sock_close(sd);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200744 sd = socket(server_addr->sa_family, SOCK_STREAM, 0);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100745 if (sd == -1)
746 {
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200747 ch_error(channel, "in socket() in channel_connect().");
748 PERROR(_("E898: socket() in channel_connect()"));
749 return -1;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100750 }
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100751
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200752 if (*waittime >= 0)
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100753 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100754 // Make connect() non-blocking.
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100755 if (
Bram Moolenaar4f974752019-02-17 17:44:42 +0100756#ifdef MSWIN
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100757 ioctlsocket(sd, FIONBIO, &val) < 0
758#else
759 fcntl(sd, F_SETFL, O_NONBLOCK) < 0
760#endif
761 )
762 {
763 SOCK_ERRNO;
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200764 ch_error(channel,
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200765 "channel_connect: Connect failed with errno %d", errno);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100766 sock_close(sd);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200767 return -1;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100768 }
769 }
770
Bram Moolenaarc667da52019-11-30 20:52:27 +0100771 // Try connecting to the server.
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200772 ch_log(channel, "Connecting...");
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100773
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200774 ret = connect(sd, server_addr, server_addrlen);
Bram Moolenaar045a2842016-03-08 22:33:07 +0100775 if (ret == 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100776 // The connection could be established.
Bram Moolenaar045a2842016-03-08 22:33:07 +0100777 break;
778
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100779 SOCK_ERRNO;
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200780 if (*waittime < 0 || (errno != EWOULDBLOCK
Bram Moolenaar045a2842016-03-08 22:33:07 +0100781 && errno != ECONNREFUSED
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100782#ifdef EINPROGRESS
Bram Moolenaar045a2842016-03-08 22:33:07 +0100783 && errno != EINPROGRESS
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100784#endif
Bram Moolenaar045a2842016-03-08 22:33:07 +0100785 ))
786 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200787 ch_error(channel,
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200788 "channel_connect: Connect failed with errno %d", errno);
Bram Moolenaar045a2842016-03-08 22:33:07 +0100789 PERROR(_(e_cannot_connect));
790 sock_close(sd);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200791 return -1;
792 }
793 else if (errno == ECONNREFUSED)
794 {
795 ch_error(channel, "channel_connect: Connection refused");
796 sock_close(sd);
797 return -1;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100798 }
Bram Moolenaard04a0202016-01-26 23:30:18 +0100799
Bram Moolenaarc667da52019-11-30 20:52:27 +0100800 // Limit the waittime to 50 msec. If it doesn't work within this
801 // time we close the socket and try creating it again.
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200802 waitnow = *waittime > 50 ? 50 : *waittime;
Bram Moolenaar40e8cb22016-03-10 21:10:58 +0100803
Bram Moolenaarc667da52019-11-30 20:52:27 +0100804 // If connect() didn't finish then try using select() to wait for the
805 // connection to be made. For Win32 always use select() to wait.
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100806 {
807 struct timeval tv;
Bram Moolenaard42119f2016-02-28 20:51:49 +0100808 fd_set rfds;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100809 fd_set wfds;
Bram Moolenaar4f974752019-02-17 17:44:42 +0100810#ifndef MSWIN
Bram Moolenaard42119f2016-02-28 20:51:49 +0100811 int so_error = 0;
812 socklen_t so_error_len = sizeof(so_error);
Bram Moolenaar045a2842016-03-08 22:33:07 +0100813 struct timeval start_tv;
814 struct timeval end_tv;
Bram Moolenaare081e212016-02-28 22:33:46 +0100815#endif
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100816 FD_ZERO(&rfds);
817 FD_SET(sd, &rfds);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100818 FD_ZERO(&wfds);
819 FD_SET(sd, &wfds);
Bram Moolenaare74e8e72016-02-16 22:01:30 +0100820
Bram Moolenaar562ca712016-03-09 21:50:05 +0100821 tv.tv_sec = waitnow / 1000;
822 tv.tv_usec = (waitnow % 1000) * 1000;
Bram Moolenaar4f974752019-02-17 17:44:42 +0100823#ifndef MSWIN
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100824 gettimeofday(&start_tv, NULL);
825#endif
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200826 ch_log(channel,
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200827 "Waiting for connection (waiting %d msec)...", waitnow);
Bram Moolenaare74e8e72016-02-16 22:01:30 +0100828
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200829 ret = select((int)sd + 1, &rfds, &wfds, NULL, &tv);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100830 if (ret < 0)
831 {
832 SOCK_ERRNO;
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200833 ch_error(channel,
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200834 "channel_connect: Connect failed with errno %d", errno);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100835 PERROR(_(e_cannot_connect));
836 sock_close(sd);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200837 return -1;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100838 }
Bram Moolenaard42119f2016-02-28 20:51:49 +0100839
Bram Moolenaar4f974752019-02-17 17:44:42 +0100840#ifdef MSWIN
Bram Moolenaarc667da52019-11-30 20:52:27 +0100841 // On Win32: select() is expected to work and wait for up to
842 // "waitnow" msec for the socket to be open.
Bram Moolenaar045a2842016-03-08 22:33:07 +0100843 if (FD_ISSET(sd, &wfds))
844 break;
Bram Moolenaar562ca712016-03-09 21:50:05 +0100845 elapsed_msec = waitnow;
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200846 if (*waittime > 1 && elapsed_msec < *waittime)
Bram Moolenaar562ca712016-03-09 21:50:05 +0100847 {
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200848 *waittime -= elapsed_msec;
Bram Moolenaar562ca712016-03-09 21:50:05 +0100849 continue;
850 }
Bram Moolenaare081e212016-02-28 22:33:46 +0100851#else
Bram Moolenaarc667da52019-11-30 20:52:27 +0100852 // On Linux-like systems: See socket(7) for the behavior
853 // After putting the socket in non-blocking mode, connect() will
854 // return EINPROGRESS, select() will not wait (as if writing is
855 // possible), need to use getsockopt() to check if the socket is
856 // actually able to connect.
857 // We detect a failure to connect when either read and write fds
858 // are set. Use getsockopt() to find out what kind of failure.
Bram Moolenaar42bc6dd2016-03-02 20:48:47 +0100859 if (FD_ISSET(sd, &rfds) || FD_ISSET(sd, &wfds))
Bram Moolenaard42119f2016-02-28 20:51:49 +0100860 {
861 ret = getsockopt(sd,
Bram Moolenaar045a2842016-03-08 22:33:07 +0100862 SOL_SOCKET, SO_ERROR, &so_error, &so_error_len);
Bram Moolenaard42119f2016-02-28 20:51:49 +0100863 if (ret < 0 || (so_error != 0
864 && so_error != EWOULDBLOCK
865 && so_error != ECONNREFUSED
Bram Moolenaare081e212016-02-28 22:33:46 +0100866# ifdef EINPROGRESS
Bram Moolenaard42119f2016-02-28 20:51:49 +0100867 && so_error != EINPROGRESS
Bram Moolenaare081e212016-02-28 22:33:46 +0100868# endif
Bram Moolenaard42119f2016-02-28 20:51:49 +0100869 ))
870 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200871 ch_error(channel,
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200872 "channel_connect: Connect failed with errno %d",
Bram Moolenaard42119f2016-02-28 20:51:49 +0100873 so_error);
874 PERROR(_(e_cannot_connect));
875 sock_close(sd);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200876 return -1;
877 }
878 else if (errno == ECONNREFUSED)
879 {
880 ch_error(channel, "channel_connect: Connection refused");
881 sock_close(sd);
882 return -1;
Bram Moolenaard42119f2016-02-28 20:51:49 +0100883 }
884 }
885
Bram Moolenaar045a2842016-03-08 22:33:07 +0100886 if (FD_ISSET(sd, &wfds) && so_error == 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100887 // Did not detect an error, connection is established.
Bram Moolenaar045a2842016-03-08 22:33:07 +0100888 break;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100889
Bram Moolenaar045a2842016-03-08 22:33:07 +0100890 gettimeofday(&end_tv, NULL);
891 elapsed_msec = (end_tv.tv_sec - start_tv.tv_sec) * 1000
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200892 + (end_tv.tv_usec - start_tv.tv_usec) / 1000;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100893#endif
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100894 }
Bram Moolenaar045a2842016-03-08 22:33:07 +0100895
Bram Moolenaar4f974752019-02-17 17:44:42 +0100896#ifndef MSWIN
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200897 if (*waittime > 1 && elapsed_msec < *waittime)
Bram Moolenaar045a2842016-03-08 22:33:07 +0100898 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100899 // The port isn't ready but we also didn't get an error.
900 // This happens when the server didn't open the socket
901 // yet. Select() may return early, wait until the remaining
902 // "waitnow" and try again.
Bram Moolenaar562ca712016-03-09 21:50:05 +0100903 waitnow -= elapsed_msec;
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200904 *waittime -= elapsed_msec;
Bram Moolenaar562ca712016-03-09 21:50:05 +0100905 if (waitnow > 0)
906 {
907 mch_delay((long)waitnow, TRUE);
908 ui_breakcheck();
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200909 *waittime -= waitnow;
Bram Moolenaar562ca712016-03-09 21:50:05 +0100910 }
Bram Moolenaar045a2842016-03-08 22:33:07 +0100911 if (!got_int)
912 {
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200913 if (*waittime <= 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100914 // give it one more try
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200915 *waittime = 1;
Bram Moolenaar045a2842016-03-08 22:33:07 +0100916 continue;
917 }
Bram Moolenaarc667da52019-11-30 20:52:27 +0100918 // we were interrupted, behave as if timed out
Bram Moolenaar045a2842016-03-08 22:33:07 +0100919 }
920#endif
921
Bram Moolenaarc667da52019-11-30 20:52:27 +0100922 // We timed out.
Bram Moolenaar045a2842016-03-08 22:33:07 +0100923 ch_error(channel, "Connection timed out");
924 sock_close(sd);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200925 return -1;
Bram Moolenaar7a84dbe2016-02-07 21:29:00 +0100926 }
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100927
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200928 if (*waittime >= 0)
Bram Moolenaar7a84dbe2016-02-07 21:29:00 +0100929 {
Bram Moolenaar4f974752019-02-17 17:44:42 +0100930#ifdef MSWIN
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100931 val = 0;
932 ioctlsocket(sd, FIONBIO, &val);
933#else
Bram Moolenaarfbc4b4d2016-02-07 15:14:01 +0100934 (void)fcntl(sd, F_SETFL, 0);
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100935#endif
936 }
937
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200938 return sd;
939}
940
941/*
942 * Open a socket channel to "hostname":"port".
943 * "waittime" is the time in msec to wait for the connection.
944 * When negative wait forever.
945 * Returns the channel for success.
946 * Returns NULL for failure.
947 */
948 channel_T *
949channel_open(
950 const char *hostname,
951 int port,
952 int waittime,
953 void (*nb_close_cb)(void))
954{
955 int sd = -1;
956 channel_T *channel = NULL;
957#ifdef FEAT_IPV6
Bram Moolenaara38b2b72020-05-03 17:03:29 +0200958 int err;
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200959 struct addrinfo hints;
960 struct addrinfo *res = NULL;
961 struct addrinfo *addr = NULL;
962#else
963 struct sockaddr_in server;
964 struct hostent *host = NULL;
965#endif
966
967#ifdef MSWIN
968 channel_init_winsock();
969#endif
970
971 channel = add_channel();
972 if (channel == NULL)
973 {
974 ch_error(NULL, "Cannot allocate channel.");
975 return NULL;
976 }
977
978 // Get the server internet address and put into addr structure fill in the
979 // socket address structure and connect to server.
980#ifdef FEAT_IPV6
Bram Moolenaara80faa82020-04-12 19:37:17 +0200981 CLEAR_FIELD(hints);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200982 hints.ai_family = AF_UNSPEC;
983 hints.ai_socktype = SOCK_STREAM;
984# ifdef AI_ADDRCONFIG
985 hints.ai_flags = AI_ADDRCONFIG;
986# endif
987 // Set port number manually in order to prevent name resolution services
988 // from being invoked in the environment where AI_NUMERICSERV is not
989 // defined.
Bram Moolenaara38b2b72020-05-03 17:03:29 +0200990 if ((err = getaddrinfo(hostname, NULL, &hints, &res)) != 0)
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200991 {
992 ch_error(channel, "in getaddrinfo() in channel_open()");
Bram Moolenaara38b2b72020-05-03 17:03:29 +0200993 semsg(_("E901: getaddrinfo() in channel_open(): %s"),
994 gai_strerror(err));
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200995 channel_free(channel);
996 return NULL;
997 }
998
999 for (addr = res; addr != NULL; addr = addr->ai_next)
1000 {
Bram Moolenaarb6fb0512020-04-18 18:24:18 +02001001 const char *dst = hostname;
Bram Moolenaarb6fb0512020-04-18 18:24:18 +02001002# ifdef HAVE_INET_NTOP
Bram Moolenaarb60db8b2020-05-29 21:38:42 +02001003 const void *src = NULL;
Bram Moolenaarb6fb0512020-04-18 18:24:18 +02001004 char buf[NUMBUFLEN];
Bram Moolenaar208534d2020-05-30 13:07:39 +02001005# endif
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001006
1007 if (addr->ai_family == AF_INET6)
1008 {
1009 struct sockaddr_in6 *sai = (struct sockaddr_in6 *)addr->ai_addr;
1010
1011 sai->sin6_port = htons(port);
Bram Moolenaar208534d2020-05-30 13:07:39 +02001012# ifdef HAVE_INET_NTOP
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001013 src = &sai->sin6_addr;
Bram Moolenaar208534d2020-05-30 13:07:39 +02001014# endif
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001015 }
1016 else if (addr->ai_family == AF_INET)
1017 {
1018 struct sockaddr_in *sai = (struct sockaddr_in *)addr->ai_addr;
1019
1020 sai->sin_port = htons(port);
Bram Moolenaar208534d2020-05-30 13:07:39 +02001021# ifdef HAVE_INET_NTOP
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001022 src = &sai->sin_addr;
Bram Moolenaar208534d2020-05-30 13:07:39 +02001023#endif
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001024 }
Bram Moolenaar208534d2020-05-30 13:07:39 +02001025# ifdef HAVE_INET_NTOP
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001026 if (src != NULL)
1027 {
1028 dst = inet_ntop(addr->ai_family, src, buf, sizeof(buf));
Bram Moolenaarb6fb0512020-04-18 18:24:18 +02001029 if (dst == NULL)
1030 dst = hostname;
1031 else if (STRCMP(hostname, dst) != 0)
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001032 ch_log(channel, "Resolved %s to %s", hostname, dst);
1033 }
Bram Moolenaarb6fb0512020-04-18 18:24:18 +02001034# endif
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001035
1036 ch_log(channel, "Trying to connect to %s port %d", dst, port);
1037
1038 // On Mac and Solaris a zero timeout almost never works. At least wait
1039 // one millisecond. Let's do it for all systems, because we don't know
1040 // why this is needed.
1041 if (waittime == 0)
1042 waittime = 1;
1043
Bram Moolenaarea554ca2020-05-07 17:46:59 +02001044 sd = channel_connect(channel, addr->ai_addr, (int)addr->ai_addrlen,
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001045 &waittime);
1046 if (sd >= 0)
1047 break;
1048 }
1049
1050 freeaddrinfo(res);
1051#else
Bram Moolenaara80faa82020-04-12 19:37:17 +02001052 CLEAR_FIELD(server);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001053 server.sin_family = AF_INET;
1054 server.sin_port = htons(port);
1055 if ((host = gethostbyname(hostname)) == NULL)
1056 {
1057 ch_error(channel, "in gethostbyname() in channel_open()");
1058 PERROR(_("E901: gethostbyname() in channel_open()"));
1059 channel_free(channel);
1060 return NULL;
1061 }
1062 {
1063 char *p;
1064
1065 // When using host->h_addr_list[0] directly ubsan warns for it to not
1066 // be aligned. First copy the pointer to avoid that.
1067 memcpy(&p, &host->h_addr_list[0], sizeof(p));
1068 memcpy((char *)&server.sin_addr, p, host->h_length);
1069 }
1070
1071 ch_log(channel, "Trying to connect to %s port %d", hostname, port);
1072
1073 // On Mac and Solaris a zero timeout almost never works. At least wait one
1074 // millisecond. Let's do it for all systems, because we don't know why
1075 // this is needed.
1076 if (waittime == 0)
1077 waittime = 1;
1078
1079 sd = channel_connect(channel, (struct sockaddr *)&server, sizeof(server),
1080 &waittime);
1081#endif
1082
1083 if (sd < 0)
1084 {
1085 channel_free(channel);
1086 return NULL;
1087 }
1088
1089 ch_log(channel, "Connection made");
1090
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001091 channel->CH_SOCK_FD = (sock_T)sd;
Bram Moolenaar4e221c92016-02-23 13:20:22 +01001092 channel->ch_nb_close_cb = nb_close_cb;
Bram Moolenaar03602ec2016-03-20 20:57:45 +01001093 channel->ch_hostname = (char *)vim_strsave((char_u *)hostname);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001094 channel->ch_port = port;
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02001095 channel->ch_to_be_closed |= (1U << PART_SOCK);
Bram Moolenaard04a0202016-01-26 23:30:18 +01001096
1097#ifdef FEAT_GUI
Bram Moolenaarde279892016-03-11 22:19:44 +01001098 channel_gui_register_one(channel, PART_SOCK);
Bram Moolenaard04a0202016-01-26 23:30:18 +01001099#endif
1100
Bram Moolenaar77073442016-02-13 23:23:53 +01001101 return channel;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001102}
1103
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001104 static void
1105free_set_callback(callback_T *cbp, callback_T *callback)
1106{
1107 free_callback(cbp);
1108
1109 if (callback->cb_name != NULL && *callback->cb_name != NUL)
1110 copy_callback(cbp, callback);
1111 else
1112 cbp->cb_name = NULL;
1113}
1114
1115/*
1116 * Prepare buffer "buf" for writing channel output to.
1117 */
1118 static void
1119prepare_buffer(buf_T *buf)
1120{
1121 buf_T *save_curbuf = curbuf;
1122
1123 buf_copy_options(buf, BCO_ENTER);
1124 curbuf = buf;
1125#ifdef FEAT_QUICKFIX
1126 set_option_value((char_u *)"bt", 0L, (char_u *)"nofile", OPT_LOCAL);
1127 set_option_value((char_u *)"bh", 0L, (char_u *)"hide", OPT_LOCAL);
1128#endif
1129 if (curbuf->b_ml.ml_mfp == NULL)
1130 ml_open(curbuf);
1131 curbuf = save_curbuf;
1132}
1133
1134/*
1135 * Find a buffer matching "name" or create a new one.
1136 * Returns NULL if there is something very wrong (error already reported).
1137 */
1138 static buf_T *
Bram Moolenaar261f3462019-09-07 15:45:32 +02001139channel_find_buffer(char_u *name, int err, int msg)
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001140{
1141 buf_T *buf = NULL;
1142 buf_T *save_curbuf = curbuf;
1143
1144 if (name != NULL && *name != NUL)
1145 {
1146 buf = buflist_findname(name);
1147 if (buf == NULL)
1148 buf = buflist_findname_exp(name);
1149 }
1150 if (buf == NULL)
1151 {
1152 buf = buflist_new(name == NULL || *name == NUL ? NULL : name,
1153 NULL, (linenr_T)0, BLN_LISTED | BLN_NEW);
1154 if (buf == NULL)
1155 return NULL;
1156 prepare_buffer(buf);
1157
1158 curbuf = buf;
1159 if (msg)
1160 ml_replace(1, (char_u *)(err ? "Reading from channel error..."
1161 : "Reading from channel output..."), TRUE);
1162 changed_bytes(1, 0);
1163 curbuf = save_curbuf;
1164 }
1165
1166 return buf;
1167}
1168
1169/*
1170 * Set various properties from an "opt" argument.
1171 */
1172 static void
1173channel_set_options(channel_T *channel, jobopt_T *opt)
1174{
1175 ch_part_T part;
1176
1177 if (opt->jo_set & JO_MODE)
1178 for (part = PART_SOCK; part < PART_COUNT; ++part)
1179 channel->ch_part[part].ch_mode = opt->jo_mode;
1180 if (opt->jo_set & JO_IN_MODE)
1181 channel->ch_part[PART_IN].ch_mode = opt->jo_in_mode;
1182 if (opt->jo_set & JO_OUT_MODE)
1183 channel->ch_part[PART_OUT].ch_mode = opt->jo_out_mode;
1184 if (opt->jo_set & JO_ERR_MODE)
1185 channel->ch_part[PART_ERR].ch_mode = opt->jo_err_mode;
1186 channel->ch_nonblock = opt->jo_noblock;
1187
1188 if (opt->jo_set & JO_TIMEOUT)
1189 for (part = PART_SOCK; part < PART_COUNT; ++part)
1190 channel->ch_part[part].ch_timeout = opt->jo_timeout;
1191 if (opt->jo_set & JO_OUT_TIMEOUT)
1192 channel->ch_part[PART_OUT].ch_timeout = opt->jo_out_timeout;
1193 if (opt->jo_set & JO_ERR_TIMEOUT)
1194 channel->ch_part[PART_ERR].ch_timeout = opt->jo_err_timeout;
1195 if (opt->jo_set & JO_BLOCK_WRITE)
1196 channel->ch_part[PART_IN].ch_block_write = 1;
1197
1198 if (opt->jo_set & JO_CALLBACK)
1199 free_set_callback(&channel->ch_callback, &opt->jo_callback);
1200 if (opt->jo_set & JO_OUT_CALLBACK)
1201 free_set_callback(&channel->ch_part[PART_OUT].ch_callback,
1202 &opt->jo_out_cb);
1203 if (opt->jo_set & JO_ERR_CALLBACK)
1204 free_set_callback(&channel->ch_part[PART_ERR].ch_callback,
1205 &opt->jo_err_cb);
1206 if (opt->jo_set & JO_CLOSE_CALLBACK)
1207 free_set_callback(&channel->ch_close_cb, &opt->jo_close_cb);
1208 channel->ch_drop_never = opt->jo_drop_never;
1209
1210 if ((opt->jo_set & JO_OUT_IO) && opt->jo_io[PART_OUT] == JIO_BUFFER)
1211 {
1212 buf_T *buf;
1213
Bram Moolenaarc667da52019-11-30 20:52:27 +01001214 // writing output to a buffer. Default mode is NL.
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001215 if (!(opt->jo_set & JO_OUT_MODE))
1216 channel->ch_part[PART_OUT].ch_mode = MODE_NL;
1217 if (opt->jo_set & JO_OUT_BUF)
1218 {
1219 buf = buflist_findnr(opt->jo_io_buf[PART_OUT]);
1220 if (buf == NULL)
1221 semsg(_(e_nobufnr), (long)opt->jo_io_buf[PART_OUT]);
1222 }
1223 else
1224 {
1225 int msg = TRUE;
1226
1227 if (opt->jo_set2 & JO2_OUT_MSG)
1228 msg = opt->jo_message[PART_OUT];
Bram Moolenaar261f3462019-09-07 15:45:32 +02001229 buf = channel_find_buffer(opt->jo_io_name[PART_OUT], FALSE, msg);
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001230 }
1231 if (buf != NULL)
1232 {
1233 if (opt->jo_set & JO_OUT_MODIFIABLE)
1234 channel->ch_part[PART_OUT].ch_nomodifiable =
1235 !opt->jo_modifiable[PART_OUT];
1236
1237 if (!buf->b_p_ma && !channel->ch_part[PART_OUT].ch_nomodifiable)
1238 {
1239 emsg(_(e_modifiable));
1240 }
1241 else
1242 {
1243 ch_log(channel, "writing out to buffer '%s'",
1244 (char *)buf->b_ffname);
1245 set_bufref(&channel->ch_part[PART_OUT].ch_bufref, buf);
1246 // if the buffer was deleted or unloaded resurrect it
1247 if (buf->b_ml.ml_mfp == NULL)
1248 prepare_buffer(buf);
1249 }
1250 }
1251 }
1252
1253 if ((opt->jo_set & JO_ERR_IO) && (opt->jo_io[PART_ERR] == JIO_BUFFER
1254 || (opt->jo_io[PART_ERR] == JIO_OUT && (opt->jo_set & JO_OUT_IO)
1255 && opt->jo_io[PART_OUT] == JIO_BUFFER)))
1256 {
1257 buf_T *buf;
1258
Bram Moolenaarc667da52019-11-30 20:52:27 +01001259 // writing err to a buffer. Default mode is NL.
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001260 if (!(opt->jo_set & JO_ERR_MODE))
1261 channel->ch_part[PART_ERR].ch_mode = MODE_NL;
1262 if (opt->jo_io[PART_ERR] == JIO_OUT)
1263 buf = channel->ch_part[PART_OUT].ch_bufref.br_buf;
1264 else if (opt->jo_set & JO_ERR_BUF)
1265 {
1266 buf = buflist_findnr(opt->jo_io_buf[PART_ERR]);
1267 if (buf == NULL)
1268 semsg(_(e_nobufnr), (long)opt->jo_io_buf[PART_ERR]);
1269 }
1270 else
1271 {
1272 int msg = TRUE;
1273
1274 if (opt->jo_set2 & JO2_ERR_MSG)
1275 msg = opt->jo_message[PART_ERR];
Bram Moolenaar261f3462019-09-07 15:45:32 +02001276 buf = channel_find_buffer(opt->jo_io_name[PART_ERR], TRUE, msg);
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001277 }
1278 if (buf != NULL)
1279 {
1280 if (opt->jo_set & JO_ERR_MODIFIABLE)
1281 channel->ch_part[PART_ERR].ch_nomodifiable =
1282 !opt->jo_modifiable[PART_ERR];
1283 if (!buf->b_p_ma && !channel->ch_part[PART_ERR].ch_nomodifiable)
1284 {
1285 emsg(_(e_modifiable));
1286 }
1287 else
1288 {
1289 ch_log(channel, "writing err to buffer '%s'",
1290 (char *)buf->b_ffname);
1291 set_bufref(&channel->ch_part[PART_ERR].ch_bufref, buf);
1292 // if the buffer was deleted or unloaded resurrect it
1293 if (buf->b_ml.ml_mfp == NULL)
1294 prepare_buffer(buf);
1295 }
1296 }
1297 }
1298
1299 channel->ch_part[PART_OUT].ch_io = opt->jo_io[PART_OUT];
1300 channel->ch_part[PART_ERR].ch_io = opt->jo_io[PART_ERR];
1301 channel->ch_part[PART_IN].ch_io = opt->jo_io[PART_IN];
1302}
1303
1304/*
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001305 * Implements ch_open().
1306 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02001307 static channel_T *
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001308channel_open_func(typval_T *argvars)
1309{
1310 char_u *address;
1311 char_u *p;
1312 char *rest;
1313 int port;
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001314 int is_ipv6 = FALSE;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001315 jobopt_T opt;
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02001316 channel_T *channel = NULL;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001317
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001318 address = tv_get_string(&argvars[0]);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001319 if (argvars[1].v_type != VAR_UNKNOWN
1320 && (argvars[1].v_type != VAR_DICT || argvars[1].vval.v_dict == NULL))
1321 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001322 emsg(_(e_invarg));
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001323 return NULL;
1324 }
1325
Bram Moolenaarc667da52019-11-30 20:52:27 +01001326 // parse address
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001327 if (*address == '[')
1328 {
1329 // ipv6 address
1330 is_ipv6 = TRUE;
1331 p = vim_strchr(address + 1, ']');
1332 if (p == NULL || *++p != ':')
1333 {
1334 semsg(_(e_invarg2), address);
1335 return NULL;
1336 }
1337 }
1338 else
1339 {
1340 p = vim_strchr(address, ':');
1341 if (p == NULL)
1342 {
1343 semsg(_(e_invarg2), address);
1344 return NULL;
1345 }
1346 }
1347 port = strtol((char *)(p + 1), &rest, 10);
1348 if (*address == NUL || port <= 0 || port >= 65536 || *rest != NUL)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001349 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001350 semsg(_(e_invarg2), address);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001351 return NULL;
1352 }
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001353 if (is_ipv6)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001354 {
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001355 // strip '[' and ']'
1356 ++address;
1357 *(p - 1) = NUL;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001358 }
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001359 else
1360 *p = NUL;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001361
Bram Moolenaarc667da52019-11-30 20:52:27 +01001362 // parse options
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001363 clear_job_options(&opt);
1364 opt.jo_mode = MODE_JSON;
1365 opt.jo_timeout = 2000;
1366 if (get_job_options(&argvars[1], &opt,
Bram Moolenaar08d384f2017-08-11 21:51:23 +02001367 JO_MODE_ALL + JO_CB_ALL + JO_WAITTIME + JO_TIMEOUT_ALL, 0) == FAIL)
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02001368 goto theend;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001369 if (opt.jo_timeout < 0)
1370 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001371 emsg(_(e_invarg));
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02001372 goto theend;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001373 }
1374
1375 channel = channel_open((char *)address, port, opt.jo_waittime, NULL);
1376 if (channel != NULL)
1377 {
1378 opt.jo_set = JO_ALL;
1379 channel_set_options(channel, &opt);
1380 }
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02001381theend:
1382 free_job_options(&opt);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001383 return channel;
1384}
1385
Bram Moolenaarde279892016-03-11 22:19:44 +01001386 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001387ch_close_part(channel_T *channel, ch_part_T part)
Bram Moolenaarde279892016-03-11 22:19:44 +01001388{
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001389 sock_T *fd = &channel->ch_part[part].ch_fd;
1390
Bram Moolenaarde279892016-03-11 22:19:44 +01001391 if (*fd != INVALID_FD)
1392 {
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001393 if (part == PART_SOCK)
1394 sock_close(*fd);
1395 else
Bram Moolenaar5a1feb82017-07-22 18:04:08 +02001396 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01001397 // When using a pty the same FD is set on multiple parts, only
1398 // close it when the last reference is closed.
Bram Moolenaar7c9aec42017-08-03 13:51:25 +02001399 if ((part == PART_IN || channel->CH_IN_FD != *fd)
1400 && (part == PART_OUT || channel->CH_OUT_FD != *fd)
1401 && (part == PART_ERR || channel->CH_ERR_FD != *fd))
Bram Moolenaar2dc9d262017-09-08 14:39:30 +02001402 {
Bram Moolenaar4f974752019-02-17 17:44:42 +01001403#ifdef MSWIN
Bram Moolenaar2dc9d262017-09-08 14:39:30 +02001404 if (channel->ch_named_pipe)
1405 DisconnectNamedPipe((HANDLE)fd);
1406#endif
Bram Moolenaar5a1feb82017-07-22 18:04:08 +02001407 fd_close(*fd);
Bram Moolenaar2dc9d262017-09-08 14:39:30 +02001408 }
Bram Moolenaar5a1feb82017-07-22 18:04:08 +02001409 }
Bram Moolenaarde279892016-03-11 22:19:44 +01001410 *fd = INVALID_FD;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001411
Bram Moolenaarc667da52019-11-30 20:52:27 +01001412 // channel is closed, may want to end the job if it was the last
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02001413 channel->ch_to_be_closed &= ~(1U << part);
Bram Moolenaarde279892016-03-11 22:19:44 +01001414 }
1415}
1416
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001417 void
Bram Moolenaard8070362016-02-15 21:56:54 +01001418channel_set_pipes(channel_T *channel, sock_T in, sock_T out, sock_T err)
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001419{
Bram Moolenaarde279892016-03-11 22:19:44 +01001420 if (in != INVALID_FD)
1421 {
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001422 ch_close_part(channel, PART_IN);
Bram Moolenaarde279892016-03-11 22:19:44 +01001423 channel->CH_IN_FD = in;
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02001424# if defined(UNIX)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001425 // Do not end the job when all output channels are closed, wait until
1426 // the job ended.
Bram Moolenaar1ecc5e42019-01-26 15:12:55 +01001427 if (mch_isatty(in))
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02001428 channel->ch_to_be_closed |= (1U << PART_IN);
1429# endif
Bram Moolenaarde279892016-03-11 22:19:44 +01001430 }
1431 if (out != INVALID_FD)
1432 {
1433# if defined(FEAT_GUI)
1434 channel_gui_unregister_one(channel, PART_OUT);
1435# endif
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001436 ch_close_part(channel, PART_OUT);
Bram Moolenaarde279892016-03-11 22:19:44 +01001437 channel->CH_OUT_FD = out;
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02001438 channel->ch_to_be_closed |= (1U << PART_OUT);
Bram Moolenaarde279892016-03-11 22:19:44 +01001439# if defined(FEAT_GUI)
1440 channel_gui_register_one(channel, PART_OUT);
1441# endif
1442 }
1443 if (err != INVALID_FD)
1444 {
1445# if defined(FEAT_GUI)
1446 channel_gui_unregister_one(channel, PART_ERR);
1447# endif
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001448 ch_close_part(channel, PART_ERR);
Bram Moolenaarde279892016-03-11 22:19:44 +01001449 channel->CH_ERR_FD = err;
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02001450 channel->ch_to_be_closed |= (1U << PART_ERR);
Bram Moolenaarde279892016-03-11 22:19:44 +01001451# if defined(FEAT_GUI)
1452 channel_gui_register_one(channel, PART_ERR);
1453# endif
1454 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001455}
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001456
Bram Moolenaard6051b52016-02-28 15:49:03 +01001457/*
Bram Moolenaar014069a2016-03-03 22:51:40 +01001458 * Sets the job the channel is associated with and associated options.
Bram Moolenaard6051b52016-02-28 15:49:03 +01001459 * This does not keep a refcount, when the job is freed ch_job is cleared.
1460 */
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001461 void
Bram Moolenaar014069a2016-03-03 22:51:40 +01001462channel_set_job(channel_T *channel, job_T *job, jobopt_T *options)
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001463{
Bram Moolenaar77073442016-02-13 23:23:53 +01001464 channel->ch_job = job;
Bram Moolenaar014069a2016-03-03 22:51:40 +01001465
1466 channel_set_options(channel, options);
1467
1468 if (job->jv_in_buf != NULL)
1469 {
1470 chanpart_T *in_part = &channel->ch_part[PART_IN];
1471
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001472 set_bufref(&in_part->ch_bufref, job->jv_in_buf);
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02001473 ch_log(channel, "reading from buffer '%s'",
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001474 (char *)in_part->ch_bufref.br_buf->b_ffname);
Bram Moolenaar014069a2016-03-03 22:51:40 +01001475 if (options->jo_set & JO_IN_TOP)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001476 {
1477 if (options->jo_in_top == 0 && !(options->jo_set & JO_IN_BOT))
1478 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01001479 // Special mode: send last-but-one line when appending a line
1480 // to the buffer.
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001481 in_part->ch_bufref.br_buf->b_write_to_channel = TRUE;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001482 in_part->ch_buf_append = TRUE;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001483 in_part->ch_buf_top =
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001484 in_part->ch_bufref.br_buf->b_ml.ml_line_count + 1;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001485 }
1486 else
1487 in_part->ch_buf_top = options->jo_in_top;
1488 }
Bram Moolenaar014069a2016-03-03 22:51:40 +01001489 else
1490 in_part->ch_buf_top = 1;
1491 if (options->jo_set & JO_IN_BOT)
1492 in_part->ch_buf_bot = options->jo_in_bot;
1493 else
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001494 in_part->ch_buf_bot = in_part->ch_bufref.br_buf->b_ml.ml_line_count;
Bram Moolenaar014069a2016-03-03 22:51:40 +01001495 }
Bram Moolenaard04a0202016-01-26 23:30:18 +01001496}
1497
1498/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001499 * Set the callback for "channel"/"part" for the response with "id".
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001500 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02001501 static void
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001502channel_set_req_callback(
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001503 channel_T *channel,
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001504 ch_part_T part,
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02001505 callback_T *callback,
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001506 int id)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001507{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001508 cbq_T *head = &channel->ch_part[part].ch_cb_head;
Bram Moolenaarc799fe22019-05-28 23:08:19 +02001509 cbq_T *item = ALLOC_ONE(cbq_T);
Bram Moolenaara07fec92016-02-05 21:04:08 +01001510
1511 if (item != NULL)
1512 {
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02001513 copy_callback(&item->cq_callback, callback);
Bram Moolenaar77073442016-02-13 23:23:53 +01001514 item->cq_seq_nr = id;
1515 item->cq_prev = head->cq_prev;
1516 head->cq_prev = item;
1517 item->cq_next = NULL;
1518 if (item->cq_prev == NULL)
1519 head->cq_next = item;
1520 else
1521 item->cq_prev->cq_next = item;
Bram Moolenaara07fec92016-02-05 21:04:08 +01001522 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001523}
1524
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001525 static void
1526write_buf_line(buf_T *buf, linenr_T lnum, channel_T *channel)
1527{
1528 char_u *line = ml_get_buf(buf, lnum, FALSE);
Bram Moolenaar367aabd2016-03-08 17:13:06 +01001529 int len = (int)STRLEN(line);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001530 char_u *p;
Bram Moolenaarbf2cc5f2016-07-07 20:45:06 +02001531 int i;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001532
Bram Moolenaarc667da52019-11-30 20:52:27 +01001533 // Need to make a copy to be able to append a NL.
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001534 if ((p = alloc(len + 2)) == NULL)
1535 return;
Bram Moolenaaradb78a72016-06-27 21:10:31 +02001536 memcpy((char *)p, (char *)line, len);
Bram Moolenaarbf2cc5f2016-07-07 20:45:06 +02001537
Bram Moolenaaref68e4f2017-09-02 16:28:36 +02001538 if (channel->ch_write_text_mode)
1539 p[len] = CAR;
1540 else
1541 {
1542 for (i = 0; i < len; ++i)
1543 if (p[i] == NL)
1544 p[i] = NUL;
Bram Moolenaarbf2cc5f2016-07-07 20:45:06 +02001545
Bram Moolenaaref68e4f2017-09-02 16:28:36 +02001546 p[len] = NL;
1547 }
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001548 p[len + 1] = NUL;
Bram Moolenaar79cbdcb2016-11-11 21:14:03 +01001549 channel_send(channel, PART_IN, p, len + 1, "write_buf_line");
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001550 vim_free(p);
1551}
1552
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001553/*
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001554 * Return TRUE if "channel" can be written to.
1555 * Returns FALSE if the input is closed or the write would block.
1556 */
1557 static int
1558can_write_buf_line(channel_T *channel)
1559{
1560 chanpart_T *in_part = &channel->ch_part[PART_IN];
1561
1562 if (in_part->ch_fd == INVALID_FD)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001563 return FALSE; // pipe was closed
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001564
Bram Moolenaarc667da52019-11-30 20:52:27 +01001565 // for testing: block every other attempt to write
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001566 if (in_part->ch_block_write == 1)
1567 in_part->ch_block_write = -1;
1568 else if (in_part->ch_block_write == -1)
1569 in_part->ch_block_write = 1;
1570
Bram Moolenaarc667da52019-11-30 20:52:27 +01001571 // TODO: Win32 implementation, probably using WaitForMultipleObjects()
Bram Moolenaar4f974752019-02-17 17:44:42 +01001572#ifndef MSWIN
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001573 {
1574# if defined(HAVE_SELECT)
1575 struct timeval tval;
1576 fd_set wfds;
1577 int ret;
1578
1579 FD_ZERO(&wfds);
1580 FD_SET((int)in_part->ch_fd, &wfds);
1581 tval.tv_sec = 0;
1582 tval.tv_usec = 0;
1583 for (;;)
1584 {
1585 ret = select((int)in_part->ch_fd + 1, NULL, &wfds, NULL, &tval);
1586# ifdef EINTR
1587 SOCK_ERRNO;
1588 if (ret == -1 && errno == EINTR)
1589 continue;
1590# endif
1591 if (ret <= 0 || in_part->ch_block_write == 1)
1592 {
1593 if (ret > 0)
1594 ch_log(channel, "FAKED Input not ready for writing");
1595 else
1596 ch_log(channel, "Input not ready for writing");
1597 return FALSE;
1598 }
1599 break;
1600 }
1601# else
1602 struct pollfd fds;
1603
1604 fds.fd = in_part->ch_fd;
1605 fds.events = POLLOUT;
1606 if (poll(&fds, 1, 0) <= 0)
1607 {
1608 ch_log(channel, "Input not ready for writing");
1609 return FALSE;
1610 }
1611 if (in_part->ch_block_write == 1)
1612 {
1613 ch_log(channel, "FAKED Input not ready for writing");
1614 return FALSE;
1615 }
1616# endif
1617 }
1618#endif
1619 return TRUE;
1620}
1621
1622/*
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02001623 * Write any buffer lines to the input channel.
Bram Moolenaar014069a2016-03-03 22:51:40 +01001624 */
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001625 static void
Bram Moolenaar014069a2016-03-03 22:51:40 +01001626channel_write_in(channel_T *channel)
1627{
1628 chanpart_T *in_part = &channel->ch_part[PART_IN];
1629 linenr_T lnum;
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001630 buf_T *buf = in_part->ch_bufref.br_buf;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001631 int written = 0;
Bram Moolenaar014069a2016-03-03 22:51:40 +01001632
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001633 if (buf == NULL || in_part->ch_buf_append)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001634 return; // no buffer or using appending
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001635 if (!bufref_valid(&in_part->ch_bufref) || buf->b_ml.ml_mfp == NULL)
Bram Moolenaar014069a2016-03-03 22:51:40 +01001636 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01001637 // buffer was wiped out or unloaded
Bram Moolenaarc4da1132017-07-15 19:39:43 +02001638 ch_log(channel, "input buffer has been wiped out");
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001639 in_part->ch_bufref.br_buf = NULL;
Bram Moolenaar014069a2016-03-03 22:51:40 +01001640 return;
1641 }
Bram Moolenaar014069a2016-03-03 22:51:40 +01001642
1643 for (lnum = in_part->ch_buf_top; lnum <= in_part->ch_buf_bot
1644 && lnum <= buf->b_ml.ml_line_count; ++lnum)
1645 {
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001646 if (!can_write_buf_line(channel))
1647 break;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001648 write_buf_line(buf, lnum, channel);
1649 ++written;
Bram Moolenaar014069a2016-03-03 22:51:40 +01001650 }
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001651
1652 if (written == 1)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02001653 ch_log(channel, "written line %d to channel", (int)lnum - 1);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001654 else if (written > 1)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02001655 ch_log(channel, "written %d lines to channel", written);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001656
Bram Moolenaar014069a2016-03-03 22:51:40 +01001657 in_part->ch_buf_top = lnum;
Bram Moolenaard8b55492016-09-01 14:35:22 +02001658 if (lnum > buf->b_ml.ml_line_count || lnum > in_part->ch_buf_bot)
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001659 {
Bram Moolenaardada6d22017-09-02 17:18:35 +02001660#if defined(FEAT_TERMINAL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001661 // Send CTRL-D or "eof_chars" to close stdin on MS-Windows.
Bram Moolenaar3346cc42017-09-02 14:54:21 +02001662 if (channel->ch_job != NULL)
1663 term_send_eof(channel);
1664#endif
1665
Bram Moolenaarc667da52019-11-30 20:52:27 +01001666 // Writing is done, no longer need the buffer.
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001667 in_part->ch_bufref.br_buf = NULL;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001668 ch_log(channel, "Finished writing all lines to channel");
Bram Moolenaard8b55492016-09-01 14:35:22 +02001669
Bram Moolenaarc667da52019-11-30 20:52:27 +01001670 // Close the pipe/socket, so that the other side gets EOF.
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001671 ch_close_part(channel, PART_IN);
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001672 }
1673 else
Bram Moolenaar4ac2e8d2018-04-08 12:38:26 +02001674 ch_log(channel, "Still %ld more lines to write",
1675 (long)(buf->b_ml.ml_line_count - lnum + 1));
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001676}
1677
1678/*
Bram Moolenaaraad30bb2016-06-26 17:31:03 +02001679 * Handle buffer "buf" being freed, remove it from any channels.
Bram Moolenaare0f76d02016-05-09 20:38:53 +02001680 */
1681 void
1682channel_buffer_free(buf_T *buf)
1683{
1684 channel_T *channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001685 ch_part_T part;
Bram Moolenaare0f76d02016-05-09 20:38:53 +02001686
Bram Moolenaaraeea7212020-04-02 18:50:46 +02001687 FOR_ALL_CHANNELS(channel)
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001688 for (part = PART_SOCK; part < PART_COUNT; ++part)
Bram Moolenaare0f76d02016-05-09 20:38:53 +02001689 {
1690 chanpart_T *ch_part = &channel->ch_part[part];
1691
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001692 if (ch_part->ch_bufref.br_buf == buf)
Bram Moolenaarde7eb0a2016-05-09 20:54:33 +02001693 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02001694 ch_log(channel, "%s buffer has been wiped out",
Bram Moolenaarde7eb0a2016-05-09 20:54:33 +02001695 part_names[part]);
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001696 ch_part->ch_bufref.br_buf = NULL;
Bram Moolenaarde7eb0a2016-05-09 20:54:33 +02001697 }
Bram Moolenaare0f76d02016-05-09 20:38:53 +02001698 }
1699}
1700
1701/*
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02001702 * Write any lines waiting to be written to "channel".
1703 */
1704 static void
1705channel_write_input(channel_T *channel)
1706{
1707 chanpart_T *in_part = &channel->ch_part[PART_IN];
1708
1709 if (in_part->ch_writeque.wq_next != NULL)
1710 channel_send(channel, PART_IN, (char_u *)"", 0, "channel_write_input");
1711 else if (in_part->ch_bufref.br_buf != NULL)
1712 {
1713 if (in_part->ch_buf_append)
1714 channel_write_new_lines(in_part->ch_bufref.br_buf);
1715 else
1716 channel_write_in(channel);
1717 }
1718}
1719
1720/*
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001721 * Write any lines waiting to be written to a channel.
1722 */
1723 void
Bram Moolenaarcf089462016-06-12 21:18:43 +02001724channel_write_any_lines(void)
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001725{
1726 channel_T *channel;
1727
Bram Moolenaaraeea7212020-04-02 18:50:46 +02001728 FOR_ALL_CHANNELS(channel)
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02001729 channel_write_input(channel);
Bram Moolenaar014069a2016-03-03 22:51:40 +01001730}
1731
1732/*
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001733 * Write appended lines above the last one in "buf" to the channel.
1734 */
1735 void
1736channel_write_new_lines(buf_T *buf)
1737{
1738 channel_T *channel;
1739 int found_one = FALSE;
1740
Bram Moolenaarc667da52019-11-30 20:52:27 +01001741 // There could be more than one channel for the buffer, loop over all of
1742 // them.
Bram Moolenaaraeea7212020-04-02 18:50:46 +02001743 FOR_ALL_CHANNELS(channel)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001744 {
1745 chanpart_T *in_part = &channel->ch_part[PART_IN];
1746 linenr_T lnum;
1747 int written = 0;
1748
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001749 if (in_part->ch_bufref.br_buf == buf && in_part->ch_buf_append)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001750 {
1751 if (in_part->ch_fd == INVALID_FD)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001752 continue; // pipe was closed
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001753 found_one = TRUE;
1754 for (lnum = in_part->ch_buf_bot; lnum < buf->b_ml.ml_line_count;
1755 ++lnum)
1756 {
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001757 if (!can_write_buf_line(channel))
1758 break;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001759 write_buf_line(buf, lnum, channel);
1760 ++written;
1761 }
1762
1763 if (written == 1)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02001764 ch_log(channel, "written line %d to channel", (int)lnum - 1);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001765 else if (written > 1)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02001766 ch_log(channel, "written %d lines to channel", written);
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001767 if (lnum < buf->b_ml.ml_line_count)
Bram Moolenaar4ac2e8d2018-04-08 12:38:26 +02001768 ch_log(channel, "Still %ld more lines to write",
1769 (long)(buf->b_ml.ml_line_count - lnum));
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001770
1771 in_part->ch_buf_bot = lnum;
1772 }
1773 }
1774 if (!found_one)
1775 buf->b_write_to_channel = FALSE;
1776}
1777
1778/*
Bram Moolenaar77073442016-02-13 23:23:53 +01001779 * Invoke the "callback" on channel "channel".
Bram Moolenaar7f7c3322016-04-18 19:27:24 +02001780 * This does not redraw but sets channel_need_redraw;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001781 */
1782 static void
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02001783invoke_callback(channel_T *channel, callback_T *callback, typval_T *argv)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001784{
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001785 typval_T rettv;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001786
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +02001787 if (safe_to_invoke_callback == 0)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001788 iemsg("INTERNAL: Invoking callback when it is not safe");
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +02001789
Bram Moolenaar77073442016-02-13 23:23:53 +01001790 argv[0].v_type = VAR_CHANNEL;
1791 argv[0].vval.v_channel = channel;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001792
Bram Moolenaarc6538bc2019-08-03 18:17:11 +02001793 call_callback(callback, -1, &rettv, 2, argv);
Bram Moolenaaree1cffc2016-02-21 19:14:41 +01001794 clear_tv(&rettv);
Bram Moolenaar7f7c3322016-04-18 19:27:24 +02001795 channel_need_redraw = TRUE;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001796}
1797
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001798/*
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001799 * Return the first node from "channel"/"part" without removing it.
1800 * Returns NULL if there is nothing.
1801 */
1802 readq_T *
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001803channel_peek(channel_T *channel, ch_part_T part)
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001804{
1805 readq_T *head = &channel->ch_part[part].ch_head;
1806
1807 return head->rq_next;
1808}
1809
1810/*
1811 * Return a pointer to the first NL in "node".
1812 * Skips over NUL characters.
1813 * Returns NULL if there is no NL.
1814 */
1815 char_u *
1816channel_first_nl(readq_T *node)
1817{
1818 char_u *buffer = node->rq_buffer;
1819 long_u i;
1820
1821 for (i = 0; i < node->rq_buflen; ++i)
1822 if (buffer[i] == NL)
1823 return buffer + i;
1824 return NULL;
1825}
1826
1827/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001828 * Return the first buffer from channel "channel"/"part" and remove it.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001829 * The caller must free it.
1830 * Returns NULL if there is nothing.
1831 */
1832 char_u *
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001833channel_get(channel_T *channel, ch_part_T part, int *outlen)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001834{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001835 readq_T *head = &channel->ch_part[part].ch_head;
Bram Moolenaar77073442016-02-13 23:23:53 +01001836 readq_T *node = head->rq_next;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001837 char_u *p;
1838
Bram Moolenaar77073442016-02-13 23:23:53 +01001839 if (node == NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001840 return NULL;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001841 if (outlen != NULL)
1842 *outlen += node->rq_buflen;
Bram Moolenaarc667da52019-11-30 20:52:27 +01001843 // dispose of the node but keep the buffer
Bram Moolenaar77073442016-02-13 23:23:53 +01001844 p = node->rq_buffer;
1845 head->rq_next = node->rq_next;
1846 if (node->rq_next == NULL)
1847 head->rq_prev = NULL;
1848 else
1849 node->rq_next->rq_prev = NULL;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001850 vim_free(node);
1851 return p;
1852}
1853
1854/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001855 * Returns the whole buffer contents concatenated for "channel"/"part".
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001856 * Replaces NUL bytes with NL.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001857 */
1858 static char_u *
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001859channel_get_all(channel_T *channel, ch_part_T part, int *outlen)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001860{
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001861 readq_T *head = &channel->ch_part[part].ch_head;
Bram Moolenaar2c519cf2019-03-21 21:45:34 +01001862 readq_T *node;
Bram Moolenaaradb78a72016-06-27 21:10:31 +02001863 long_u len = 0;
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001864 char_u *res;
1865 char_u *p;
1866
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01001867 // Concatenate everything into one buffer.
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001868 for (node = head->rq_next; node != NULL; node = node->rq_next)
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001869 len += node->rq_buflen;
Bram Moolenaar18a4ba22019-05-24 19:39:03 +02001870 res = alloc(len + 1);
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001871 if (res == NULL)
1872 return NULL;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001873 p = res;
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001874 for (node = head->rq_next; node != NULL; node = node->rq_next)
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001875 {
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001876 mch_memmove(p, node->rq_buffer, node->rq_buflen);
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001877 p += node->rq_buflen;
1878 }
1879 *p = NUL;
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001880
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01001881 // Free all buffers
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001882 do
1883 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001884 p = channel_get(channel, part, NULL);
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001885 vim_free(p);
1886 } while (p != NULL);
1887
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001888 if (outlen != NULL)
1889 {
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01001890 // Returning the length, keep NUL characters.
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001891 *outlen += len;
1892 return res;
1893 }
1894
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01001895 // Turn all NUL into NL, so that the result can be used as a string.
1896 p = res;
1897 while (p < res + len)
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001898 {
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01001899 if (*p == NUL)
1900 *p = NL;
Bram Moolenaar4f974752019-02-17 17:44:42 +01001901#ifdef MSWIN
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01001902 else if (*p == 0x1b)
1903 {
1904 // crush the escape sequence OSC 0/1/2: ESC ]0;
1905 if (p + 3 < res + len
1906 && p[1] == ']'
1907 && (p[2] == '0' || p[2] == '1' || p[2] == '2')
1908 && p[3] == ';')
1909 {
1910 // '\a' becomes a NL
1911 while (p < res + (len - 1) && *p != '\a')
1912 ++p;
1913 // BEL is zero width characters, suppress display mistake
1914 // ConPTY (after 10.0.18317) requires advance checking
1915 if (p[-1] == NUL)
1916 p[-1] = 0x07;
1917 }
1918 }
1919#endif
1920 ++p;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001921 }
1922
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001923 return res;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001924}
1925
1926/*
Bram Moolenaarcf089462016-06-12 21:18:43 +02001927 * Consume "len" bytes from the head of "node".
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001928 * Caller must check these bytes are available.
1929 */
1930 void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001931channel_consume(channel_T *channel, ch_part_T part, int len)
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001932{
1933 readq_T *head = &channel->ch_part[part].ch_head;
1934 readq_T *node = head->rq_next;
1935 char_u *buf = node->rq_buffer;
1936
1937 mch_memmove(buf, buf + len, node->rq_buflen - len);
1938 node->rq_buflen -= len;
Bram Moolenaar772153f2019-03-04 12:09:49 +01001939 node->rq_buffer[node->rq_buflen] = NUL;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001940}
1941
1942/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001943 * Collapses the first and second buffer for "channel"/"part".
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001944 * Returns FAIL if that is not possible.
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001945 * When "want_nl" is TRUE collapse more buffers until a NL is found.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001946 */
1947 int
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001948channel_collapse(channel_T *channel, ch_part_T part, int want_nl)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001949{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001950 readq_T *head = &channel->ch_part[part].ch_head;
Bram Moolenaar77073442016-02-13 23:23:53 +01001951 readq_T *node = head->rq_next;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001952 readq_T *last_node;
1953 readq_T *n;
1954 char_u *newbuf;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001955 char_u *p;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001956 long_u len;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001957
Bram Moolenaar77073442016-02-13 23:23:53 +01001958 if (node == NULL || node->rq_next == NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001959 return FAIL;
1960
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001961 last_node = node->rq_next;
Bram Moolenaar772153f2019-03-04 12:09:49 +01001962 len = node->rq_buflen + last_node->rq_buflen;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001963 if (want_nl)
1964 while (last_node->rq_next != NULL
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001965 && channel_first_nl(last_node) == NULL)
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001966 {
1967 last_node = last_node->rq_next;
1968 len += last_node->rq_buflen;
1969 }
1970
Bram Moolenaar772153f2019-03-04 12:09:49 +01001971 p = newbuf = alloc(len + 1);
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001972 if (newbuf == NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001973 return FAIL; // out of memory
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001974 mch_memmove(p, node->rq_buffer, node->rq_buflen);
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001975 p += node->rq_buflen;
Bram Moolenaar77073442016-02-13 23:23:53 +01001976 vim_free(node->rq_buffer);
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001977 node->rq_buffer = newbuf;
1978 for (n = node; n != last_node; )
1979 {
1980 n = n->rq_next;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001981 mch_memmove(p, n->rq_buffer, n->rq_buflen);
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001982 p += n->rq_buflen;
1983 vim_free(n->rq_buffer);
1984 }
Bram Moolenaar772153f2019-03-04 12:09:49 +01001985 *p = NUL;
Bram Moolenaarbbe8d912016-06-05 16:10:57 +02001986 node->rq_buflen = (long_u)(p - newbuf);
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001987
Bram Moolenaarc667da52019-11-30 20:52:27 +01001988 // dispose of the collapsed nodes and their buffers
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001989 for (n = node->rq_next; n != last_node; )
1990 {
1991 n = n->rq_next;
1992 vim_free(n->rq_prev);
1993 }
1994 node->rq_next = last_node->rq_next;
1995 if (last_node->rq_next == NULL)
1996 head->rq_prev = node;
1997 else
1998 last_node->rq_next->rq_prev = node;
1999 vim_free(last_node);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002000 return OK;
2001}
2002
2003/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002004 * Store "buf[len]" on "channel"/"part".
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002005 * When "prepend" is TRUE put in front, otherwise append at the end.
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002006 * Returns OK or FAIL.
2007 */
2008 static int
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002009channel_save(channel_T *channel, ch_part_T part, char_u *buf, int len,
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002010 int prepend, char *lead)
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002011{
2012 readq_T *node;
2013 readq_T *head = &channel->ch_part[part].ch_head;
2014 char_u *p;
2015 int i;
2016
Bram Moolenaarc799fe22019-05-28 23:08:19 +02002017 node = ALLOC_ONE(readq_T);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002018 if (node == NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002019 return FAIL; // out of memory
2020 // A NUL is added at the end, because netbeans code expects that.
2021 // Otherwise a NUL may appear inside the text.
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002022 node->rq_buffer = alloc(len + 1);
2023 if (node->rq_buffer == NULL)
2024 {
2025 vim_free(node);
Bram Moolenaarc667da52019-11-30 20:52:27 +01002026 return FAIL; // out of memory
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002027 }
2028
2029 if (channel->ch_part[part].ch_mode == MODE_NL)
2030 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002031 // Drop any CR before a NL.
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002032 p = node->rq_buffer;
2033 for (i = 0; i < len; ++i)
2034 if (buf[i] != CAR || i + 1 >= len || buf[i + 1] != NL)
2035 *p++ = buf[i];
2036 *p = NUL;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02002037 node->rq_buflen = (long_u)(p - node->rq_buffer);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002038 }
2039 else
2040 {
2041 mch_memmove(node->rq_buffer, buf, len);
2042 node->rq_buffer[len] = NUL;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02002043 node->rq_buflen = (long_u)len;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002044 }
2045
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002046 if (prepend)
2047 {
Bram Moolenaarad3ec762019-04-21 00:00:13 +02002048 // prepend node to the head of the queue
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002049 node->rq_next = head->rq_next;
2050 node->rq_prev = NULL;
2051 if (head->rq_next == NULL)
2052 head->rq_prev = node;
2053 else
2054 head->rq_next->rq_prev = node;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002055 head->rq_next = node;
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002056 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002057 else
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002058 {
Bram Moolenaarad3ec762019-04-21 00:00:13 +02002059 // append node to the tail of the queue
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002060 node->rq_next = NULL;
2061 node->rq_prev = head->rq_prev;
2062 if (head->rq_prev == NULL)
2063 head->rq_next = node;
2064 else
2065 head->rq_prev->rq_next = node;
2066 head->rq_prev = node;
2067 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002068
Bram Moolenaar71eeb742017-09-13 22:18:01 +02002069 if (ch_log_active() && lead != NULL)
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002070 {
Bram Moolenaar4b16ee72018-08-09 22:15:34 +02002071 ch_log_lead(lead, channel, part);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002072 fprintf(log_fd, "'");
Bram Moolenaar42335f52018-09-13 15:33:43 +02002073 vim_ignored = (int)fwrite(buf, len, 1, log_fd);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002074 fprintf(log_fd, "'\n");
2075 }
2076 return OK;
2077}
2078
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002079/*
2080 * Try to fill the buffer of "reader".
2081 * Returns FALSE when nothing was added.
2082 */
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002083 static int
2084channel_fill(js_read_T *reader)
2085{
2086 channel_T *channel = (channel_T *)reader->js_cookie;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002087 ch_part_T part = reader->js_cookie_arg;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002088 char_u *next = channel_get(channel, part, NULL);
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002089 int keeplen;
2090 int addlen;
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002091 char_u *p;
2092
2093 if (next == NULL)
2094 return FALSE;
2095
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002096 keeplen = reader->js_end - reader->js_buf;
2097 if (keeplen > 0)
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002098 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002099 // Prepend unused text.
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002100 addlen = (int)STRLEN(next);
2101 p = alloc(keeplen + addlen + 1);
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002102 if (p == NULL)
2103 {
2104 vim_free(next);
2105 return FALSE;
2106 }
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002107 mch_memmove(p, reader->js_buf, keeplen);
2108 mch_memmove(p + keeplen, next, addlen + 1);
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002109 vim_free(next);
2110 next = p;
2111 }
2112
2113 vim_free(reader->js_buf);
2114 reader->js_buf = next;
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002115 return TRUE;
2116}
2117
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002118/*
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002119 * Use the read buffer of "channel"/"part" and parse a JSON message that is
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002120 * complete. The messages are added to the queue.
Bram Moolenaard7ece102016-02-02 23:23:02 +01002121 * Return TRUE if there is more to read.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002122 */
Bram Moolenaard7ece102016-02-02 23:23:02 +01002123 static int
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002124channel_parse_json(channel_T *channel, ch_part_T part)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002125{
2126 js_read_T reader;
2127 typval_T listtv;
2128 jsonq_T *item;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002129 chanpart_T *chanpart = &channel->ch_part[part];
2130 jsonq_T *head = &chanpart->ch_json_head;
2131 int status;
Bram Moolenaard7ece102016-02-02 23:23:02 +01002132 int ret;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002133
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002134 if (channel_peek(channel, part) == NULL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01002135 return FALSE;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002136
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002137 reader.js_buf = channel_get(channel, part, NULL);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002138 reader.js_used = 0;
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002139 reader.js_fill = channel_fill;
Bram Moolenaar77073442016-02-13 23:23:53 +01002140 reader.js_cookie = channel;
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002141 reader.js_cookie_arg = part;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002142
Bram Moolenaarc667da52019-11-30 20:52:27 +01002143 // When a message is incomplete we wait for a short while for more to
2144 // arrive. After the delay drop the input, otherwise a truncated string
2145 // or list will make us hang.
2146 // Do not generate error messages, they will be written in a channel log.
Bram Moolenaar03c60c12017-01-10 15:15:37 +01002147 ++emsg_silent;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002148 status = json_decode(&reader, &listtv,
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002149 chanpart->ch_mode == MODE_JS ? JSON_JS : 0);
Bram Moolenaar03c60c12017-01-10 15:15:37 +01002150 --emsg_silent;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002151 if (status == OK)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002152 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002153 // Only accept the response when it is a list with at least two
2154 // items.
Bram Moolenaar6076fe12016-02-05 22:49:56 +01002155 if (listtv.v_type != VAR_LIST || listtv.vval.v_list->lv_len < 2)
Bram Moolenaard7ece102016-02-02 23:23:02 +01002156 {
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002157 if (listtv.v_type != VAR_LIST)
2158 ch_error(channel, "Did not receive a list, discarding");
2159 else
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002160 ch_error(channel, "Expected list with two items, got %d",
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002161 listtv.vval.v_list->lv_len);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002162 clear_tv(&listtv);
Bram Moolenaard7ece102016-02-02 23:23:02 +01002163 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002164 else
2165 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02002166 item = ALLOC_ONE(jsonq_T);
Bram Moolenaard7ece102016-02-02 23:23:02 +01002167 if (item == NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002168 clear_tv(&listtv);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002169 else
2170 {
Bram Moolenaar958dc692016-12-01 15:34:12 +01002171 item->jq_no_callback = FALSE;
Bram Moolenaar77073442016-02-13 23:23:53 +01002172 item->jq_value = alloc_tv();
2173 if (item->jq_value == NULL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01002174 {
2175 vim_free(item);
2176 clear_tv(&listtv);
2177 }
2178 else
2179 {
Bram Moolenaar77073442016-02-13 23:23:53 +01002180 *item->jq_value = listtv;
2181 item->jq_prev = head->jq_prev;
2182 head->jq_prev = item;
2183 item->jq_next = NULL;
2184 if (item->jq_prev == NULL)
2185 head->jq_next = item;
2186 else
2187 item->jq_prev->jq_next = item;
Bram Moolenaard7ece102016-02-02 23:23:02 +01002188 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002189 }
2190 }
2191 }
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002192
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002193 if (status == OK)
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002194 chanpart->ch_wait_len = 0;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002195 else if (status == MAYBE)
Bram Moolenaard7ece102016-02-02 23:23:02 +01002196 {
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002197 size_t buflen = STRLEN(reader.js_buf);
2198
2199 if (chanpart->ch_wait_len < buflen)
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002200 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002201 // First time encountering incomplete message or after receiving
2202 // more (but still incomplete): set a deadline of 100 msec.
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002203 ch_log(channel,
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002204 "Incomplete message (%d bytes) - wait 100 msec for more",
Bram Moolenaarb113c3a2017-02-28 21:26:17 +01002205 (int)buflen);
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002206 reader.js_used = 0;
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002207 chanpart->ch_wait_len = buflen;
Bram Moolenaar4f974752019-02-17 17:44:42 +01002208#ifdef MSWIN
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002209 chanpart->ch_deadline = GetTickCount() + 100L;
2210#else
2211 gettimeofday(&chanpart->ch_deadline, NULL);
2212 chanpart->ch_deadline.tv_usec += 100 * 1000;
2213 if (chanpart->ch_deadline.tv_usec > 1000 * 1000)
2214 {
2215 chanpart->ch_deadline.tv_usec -= 1000 * 1000;
2216 ++chanpart->ch_deadline.tv_sec;
2217 }
2218#endif
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002219 }
2220 else
2221 {
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002222 int timeout;
Bram Moolenaar4f974752019-02-17 17:44:42 +01002223#ifdef MSWIN
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002224 timeout = GetTickCount() > chanpart->ch_deadline;
2225#else
2226 {
2227 struct timeval now_tv;
2228
2229 gettimeofday(&now_tv, NULL);
2230 timeout = now_tv.tv_sec > chanpart->ch_deadline.tv_sec
2231 || (now_tv.tv_sec == chanpart->ch_deadline.tv_sec
2232 && now_tv.tv_usec > chanpart->ch_deadline.tv_usec);
2233 }
2234#endif
2235 if (timeout)
2236 {
2237 status = FAIL;
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002238 chanpart->ch_wait_len = 0;
2239 ch_log(channel, "timed out");
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002240 }
2241 else
2242 {
2243 reader.js_used = 0;
2244 ch_log(channel, "still waiting on incomplete message");
2245 }
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002246 }
Bram Moolenaard7ece102016-02-02 23:23:02 +01002247 }
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002248
2249 if (status == FAIL)
2250 {
2251 ch_error(channel, "Decoding failed - discarding input");
2252 ret = FALSE;
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002253 chanpart->ch_wait_len = 0;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002254 }
2255 else if (reader.js_buf[reader.js_used] != NUL)
2256 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002257 // Put the unread part back into the channel.
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002258 channel_save(channel, part, reader.js_buf + reader.js_used,
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002259 (int)(reader.js_end - reader.js_buf) - reader.js_used,
2260 TRUE, NULL);
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002261 ret = status == MAYBE ? FALSE: TRUE;
2262 }
Bram Moolenaard7ece102016-02-02 23:23:02 +01002263 else
2264 ret = FALSE;
2265
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002266 vim_free(reader.js_buf);
Bram Moolenaard7ece102016-02-02 23:23:02 +01002267 return ret;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002268}
2269
2270/*
Bram Moolenaard46ae142016-02-16 13:33:52 +01002271 * Remove "node" from the queue that it is in. Does not free it.
Bram Moolenaara07fec92016-02-05 21:04:08 +01002272 */
2273 static void
Bram Moolenaar77073442016-02-13 23:23:53 +01002274remove_cb_node(cbq_T *head, cbq_T *node)
Bram Moolenaara07fec92016-02-05 21:04:08 +01002275{
Bram Moolenaar77073442016-02-13 23:23:53 +01002276 if (node->cq_prev == NULL)
2277 head->cq_next = node->cq_next;
2278 else
2279 node->cq_prev->cq_next = node->cq_next;
2280 if (node->cq_next == NULL)
2281 head->cq_prev = node->cq_prev;
2282 else
2283 node->cq_next->cq_prev = node->cq_prev;
Bram Moolenaara07fec92016-02-05 21:04:08 +01002284}
2285
2286/*
2287 * Remove "node" from the queue that it is in and free it.
Bram Moolenaar77073442016-02-13 23:23:53 +01002288 * Caller should have freed or used node->jq_value.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002289 */
2290 static void
Bram Moolenaar77073442016-02-13 23:23:53 +01002291remove_json_node(jsonq_T *head, jsonq_T *node)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002292{
Bram Moolenaar77073442016-02-13 23:23:53 +01002293 if (node->jq_prev == NULL)
2294 head->jq_next = node->jq_next;
2295 else
2296 node->jq_prev->jq_next = node->jq_next;
2297 if (node->jq_next == NULL)
2298 head->jq_prev = node->jq_prev;
2299 else
2300 node->jq_next->jq_prev = node->jq_prev;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002301 vim_free(node);
2302}
2303
2304/*
Bram Moolenaar38ea7842019-06-09 19:51:58 +02002305 * Add "id" to the list of JSON message IDs we are waiting on.
2306 */
2307 static void
2308channel_add_block_id(chanpart_T *chanpart, int id)
2309{
2310 garray_T *gap = &chanpart->ch_block_ids;
2311
2312 if (gap->ga_growsize == 0)
2313 ga_init2(gap, (int)sizeof(int), 10);
2314 if (ga_grow(gap, 1) == OK)
2315 {
2316 ((int *)gap->ga_data)[gap->ga_len] = id;
2317 ++gap->ga_len;
2318 }
2319}
2320
2321/*
2322 * Remove "id" from the list of JSON message IDs we are waiting on.
2323 */
2324 static void
2325channel_remove_block_id(chanpart_T *chanpart, int id)
2326{
2327 garray_T *gap = &chanpart->ch_block_ids;
2328 int i;
2329
2330 for (i = 0; i < gap->ga_len; ++i)
2331 if (((int *)gap->ga_data)[i] == id)
2332 {
2333 --gap->ga_len;
2334 if (i < gap->ga_len)
2335 {
2336 int *p = ((int *)gap->ga_data) + i;
2337
2338 mch_memmove(p, p + 1, (gap->ga_len - i) * sizeof(int));
2339 }
2340 return;
2341 }
2342 siemsg("INTERNAL: channel_remove_block_id: cannot find id %d", id);
2343}
2344
2345/*
2346 * Return TRUE if "id" is in the list of JSON message IDs we are waiting on.
2347 */
2348 static int
2349channel_has_block_id(chanpart_T *chanpart, int id)
2350{
2351 garray_T *gap = &chanpart->ch_block_ids;
2352 int i;
2353
2354 for (i = 0; i < gap->ga_len; ++i)
2355 if (((int *)gap->ga_data)[i] == id)
2356 return TRUE;
2357 return FALSE;
2358}
2359
2360/*
Bram Moolenaar77073442016-02-13 23:23:53 +01002361 * Get a message from the JSON queue for channel "channel".
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002362 * When "id" is positive it must match the first number in the list.
Bram Moolenaar38ea7842019-06-09 19:51:58 +02002363 * When "id" is zero or negative jut get the first message. But not one
2364 * in the ch_block_ids list.
Bram Moolenaar958dc692016-12-01 15:34:12 +01002365 * When "without_callback" is TRUE also get messages that were pushed back.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002366 * Return OK when found and return the value in "rettv".
2367 * Return FAIL otherwise.
2368 */
2369 static int
Bram Moolenaar958dc692016-12-01 15:34:12 +01002370channel_get_json(
2371 channel_T *channel,
2372 ch_part_T part,
2373 int id,
2374 int without_callback,
2375 typval_T **rettv)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002376{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002377 jsonq_T *head = &channel->ch_part[part].ch_json_head;
Bram Moolenaar77073442016-02-13 23:23:53 +01002378 jsonq_T *item = head->jq_next;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002379
Bram Moolenaar77073442016-02-13 23:23:53 +01002380 while (item != NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002381 {
Bram Moolenaar77073442016-02-13 23:23:53 +01002382 list_T *l = item->jq_value->vval.v_list;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002383 typval_T *tv;
2384
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02002385 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002386 tv = &l->lv_first->li_tv;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002387
Bram Moolenaar958dc692016-12-01 15:34:12 +01002388 if ((without_callback || !item->jq_no_callback)
2389 && ((id > 0 && tv->v_type == VAR_NUMBER && tv->vval.v_number == id)
Bram Moolenaare56bf152016-02-08 23:23:42 +01002390 || (id <= 0 && (tv->v_type != VAR_NUMBER
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002391 || tv->vval.v_number == 0
Bram Moolenaar38ea7842019-06-09 19:51:58 +02002392 || !channel_has_block_id(
2393 &channel->ch_part[part], tv->vval.v_number)))))
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002394 {
Bram Moolenaar77073442016-02-13 23:23:53 +01002395 *rettv = item->jq_value;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002396 if (tv->v_type == VAR_NUMBER)
Bram Moolenaar4ac2e8d2018-04-08 12:38:26 +02002397 ch_log(channel, "Getting JSON message %ld",
2398 (long)tv->vval.v_number);
Bram Moolenaar77073442016-02-13 23:23:53 +01002399 remove_json_node(head, item);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002400 return OK;
2401 }
Bram Moolenaar77073442016-02-13 23:23:53 +01002402 item = item->jq_next;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002403 }
2404 return FAIL;
2405}
2406
Bram Moolenaar958dc692016-12-01 15:34:12 +01002407/*
2408 * Put back "rettv" into the JSON queue, there was no callback for it.
2409 * Takes over the values in "rettv".
2410 */
2411 static void
2412channel_push_json(channel_T *channel, ch_part_T part, typval_T *rettv)
2413{
2414 jsonq_T *head = &channel->ch_part[part].ch_json_head;
2415 jsonq_T *item = head->jq_next;
2416 jsonq_T *newitem;
2417
2418 if (head->jq_prev != NULL && head->jq_prev->jq_no_callback)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002419 // last item was pushed back, append to the end
Bram Moolenaar958dc692016-12-01 15:34:12 +01002420 item = NULL;
2421 else while (item != NULL && item->jq_no_callback)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002422 // append after the last item that was pushed back
Bram Moolenaar958dc692016-12-01 15:34:12 +01002423 item = item->jq_next;
2424
Bram Moolenaarc799fe22019-05-28 23:08:19 +02002425 newitem = ALLOC_ONE(jsonq_T);
Bram Moolenaar958dc692016-12-01 15:34:12 +01002426 if (newitem == NULL)
2427 clear_tv(rettv);
2428 else
2429 {
2430 newitem->jq_value = alloc_tv();
2431 if (newitem->jq_value == NULL)
2432 {
2433 vim_free(newitem);
2434 clear_tv(rettv);
2435 }
2436 else
2437 {
2438 newitem->jq_no_callback = FALSE;
2439 *newitem->jq_value = *rettv;
2440 if (item == NULL)
2441 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002442 // append to the end
Bram Moolenaar958dc692016-12-01 15:34:12 +01002443 newitem->jq_prev = head->jq_prev;
2444 head->jq_prev = newitem;
2445 newitem->jq_next = NULL;
2446 if (newitem->jq_prev == NULL)
2447 head->jq_next = newitem;
2448 else
2449 newitem->jq_prev->jq_next = newitem;
2450 }
2451 else
2452 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002453 // append after "item"
Bram Moolenaar958dc692016-12-01 15:34:12 +01002454 newitem->jq_prev = item;
2455 newitem->jq_next = item->jq_next;
2456 item->jq_next = newitem;
2457 if (newitem->jq_next == NULL)
2458 head->jq_prev = newitem;
2459 else
2460 newitem->jq_next->jq_prev = newitem;
2461 }
2462 }
2463 }
2464}
2465
Bram Moolenaarece61b02016-02-20 21:39:05 +01002466#define CH_JSON_MAX_ARGS 4
2467
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002468/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002469 * Execute a command received over "channel"/"part"
Bram Moolenaarece61b02016-02-20 21:39:05 +01002470 * "argv[0]" is the command string.
2471 * "argv[1]" etc. have further arguments, type is VAR_UNKNOWN if missing.
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002472 */
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002473 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002474channel_exe_cmd(channel_T *channel, ch_part_T part, typval_T *argv)
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002475{
Bram Moolenaarece61b02016-02-20 21:39:05 +01002476 char_u *cmd = argv[0].vval.v_string;
2477 char_u *arg;
2478 int options = channel->ch_part[part].ch_mode == MODE_JS ? JSON_JS : 0;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002479
Bram Moolenaarece61b02016-02-20 21:39:05 +01002480 if (argv[1].v_type != VAR_STRING)
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002481 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01002482 ch_error(channel, "received command with non-string argument");
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002483 if (p_verbose > 2)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002484 emsg(_("E903: received command with non-string argument"));
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002485 return;
2486 }
Bram Moolenaarece61b02016-02-20 21:39:05 +01002487 arg = argv[1].vval.v_string;
Bram Moolenaar14ad6112016-02-01 21:47:13 +01002488 if (arg == NULL)
2489 arg = (char_u *)"";
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002490
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002491 if (STRCMP(cmd, "ex") == 0)
2492 {
Bram Moolenaar53989552019-12-23 22:59:18 +01002493 int called_emsg_before = called_emsg;
Bram Moolenaarc4dcd602016-03-26 22:56:46 +01002494
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002495 ch_log(channel, "Executing ex command '%s'", (char *)arg);
Bram Moolenaarc4dcd602016-03-26 22:56:46 +01002496 ++emsg_silent;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002497 do_cmdline_cmd(arg);
Bram Moolenaarc4dcd602016-03-26 22:56:46 +01002498 --emsg_silent;
Bram Moolenaar53989552019-12-23 22:59:18 +01002499 if (called_emsg > called_emsg_before)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002500 ch_log(channel, "Ex command error: '%s'",
Bram Moolenaarc4dcd602016-03-26 22:56:46 +01002501 (char *)get_vim_var_str(VV_ERRMSG));
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002502 }
2503 else if (STRCMP(cmd, "normal") == 0)
2504 {
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002505 exarg_T ea;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002506
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002507 ch_log(channel, "Executing normal command '%s'", (char *)arg);
Bram Moolenaara80faa82020-04-12 19:37:17 +02002508 CLEAR_FIELD(ea);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002509 ea.arg = arg;
2510 ea.addr_count = 0;
Bram Moolenaarc667da52019-11-30 20:52:27 +01002511 ea.forceit = TRUE; // no mapping
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002512 ex_normal(&ea);
2513 }
2514 else if (STRCMP(cmd, "redraw") == 0)
2515 {
2516 exarg_T ea;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002517
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002518 ch_log(channel, "redraw");
Bram Moolenaara80faa82020-04-12 19:37:17 +02002519 CLEAR_FIELD(ea);
Bram Moolenaar14ad6112016-02-01 21:47:13 +01002520 ea.forceit = *arg != NUL;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002521 ex_redraw(&ea);
2522 showruler(FALSE);
2523 setcursor();
Bram Moolenaara338adc2018-01-31 20:51:47 +01002524 out_flush_cursor(TRUE, FALSE);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002525 }
Bram Moolenaarece61b02016-02-20 21:39:05 +01002526 else if (STRCMP(cmd, "expr") == 0 || STRCMP(cmd, "call") == 0)
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002527 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01002528 int is_call = cmd[0] == 'c';
2529 int id_idx = is_call ? 3 : 2;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002530
Bram Moolenaarece61b02016-02-20 21:39:05 +01002531 if (argv[id_idx].v_type != VAR_UNKNOWN
2532 && argv[id_idx].v_type != VAR_NUMBER)
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002533 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01002534 ch_error(channel, "last argument for expr/call must be a number");
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002535 if (p_verbose > 2)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002536 emsg(_("E904: last argument for expr/call must be a number"));
Bram Moolenaarece61b02016-02-20 21:39:05 +01002537 }
2538 else if (is_call && argv[2].v_type != VAR_LIST)
2539 {
2540 ch_error(channel, "third argument for call must be a list");
2541 if (p_verbose > 2)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002542 emsg(_("E904: third argument for call must be a list"));
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002543 }
2544 else
2545 {
Bram Moolenaarc8fe3382016-09-04 20:44:42 +02002546 typval_T *tv = NULL;
Bram Moolenaarece61b02016-02-20 21:39:05 +01002547 typval_T res_tv;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002548 typval_T err_tv;
Bram Moolenaar55fab432016-02-07 16:53:13 +01002549 char_u *json = NULL;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002550
Bram Moolenaarc667da52019-11-30 20:52:27 +01002551 // Don't pollute the display with errors.
Bram Moolenaarfcb1e3d2016-02-03 21:32:46 +01002552 ++emsg_skip;
Bram Moolenaarece61b02016-02-20 21:39:05 +01002553 if (!is_call)
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002554 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002555 ch_log(channel, "Evaluating expression '%s'", (char *)arg);
Bram Moolenaarece61b02016-02-20 21:39:05 +01002556 tv = eval_expr(arg, NULL);
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002557 }
Bram Moolenaarece61b02016-02-20 21:39:05 +01002558 else
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002559 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002560 ch_log(channel, "Calling '%s'", (char *)arg);
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002561 if (func_call(arg, &argv[2], NULL, NULL, &res_tv) == OK)
2562 tv = &res_tv;
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002563 }
Bram Moolenaarece61b02016-02-20 21:39:05 +01002564
2565 if (argv[id_idx].v_type == VAR_NUMBER)
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002566 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01002567 int id = argv[id_idx].vval.v_number;
2568
Bram Moolenaar55fab432016-02-07 16:53:13 +01002569 if (tv != NULL)
Bram Moolenaarf1f07922016-08-26 17:58:53 +02002570 json = json_encode_nr_expr(id, tv, options | JSON_NL);
Bram Moolenaar55fab432016-02-07 16:53:13 +01002571 if (tv == NULL || (json != NULL && *json == NUL))
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002572 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002573 // If evaluation failed or the result can't be encoded
2574 // then return the string "ERROR".
Bram Moolenaar77073442016-02-13 23:23:53 +01002575 vim_free(json);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002576 err_tv.v_type = VAR_STRING;
2577 err_tv.vval.v_string = (char_u *)"ERROR";
Bram Moolenaarc8fe3382016-09-04 20:44:42 +02002578 json = json_encode_nr_expr(id, &err_tv, options | JSON_NL);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002579 }
Bram Moolenaar55fab432016-02-07 16:53:13 +01002580 if (json != NULL)
2581 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01002582 channel_send(channel,
2583 part == PART_SOCK ? PART_SOCK : PART_IN,
Bram Moolenaarbf2cc5f2016-07-07 20:45:06 +02002584 json, (int)STRLEN(json), (char *)cmd);
Bram Moolenaar55fab432016-02-07 16:53:13 +01002585 vim_free(json);
2586 }
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002587 }
Bram Moolenaar55fab432016-02-07 16:53:13 +01002588 --emsg_skip;
Bram Moolenaarece61b02016-02-20 21:39:05 +01002589 if (tv == &res_tv)
2590 clear_tv(tv);
Bram Moolenaarc8fe3382016-09-04 20:44:42 +02002591 else
Bram Moolenaarfcb1e3d2016-02-03 21:32:46 +01002592 free_tv(tv);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002593 }
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002594 }
2595 else if (p_verbose > 2)
Bram Moolenaarece61b02016-02-20 21:39:05 +01002596 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002597 ch_error(channel, "Received unknown command: %s", (char *)cmd);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002598 semsg(_("E905: received unknown command: %s"), cmd);
Bram Moolenaarece61b02016-02-20 21:39:05 +01002599 }
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002600}
2601
Bram Moolenaar7f7c3322016-04-18 19:27:24 +02002602/*
2603 * Invoke the callback at "cbhead".
2604 * Does not redraw but sets channel_need_redraw.
2605 */
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002606 static void
2607invoke_one_time_callback(
2608 channel_T *channel,
2609 cbq_T *cbhead,
2610 cbq_T *item,
2611 typval_T *argv)
2612{
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002613 ch_log(channel, "Invoking one-time callback %s",
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02002614 (char *)item->cq_callback.cb_name);
Bram Moolenaarc667da52019-11-30 20:52:27 +01002615 // Remove the item from the list first, if the callback
2616 // invokes ch_close() the list will be cleared.
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002617 remove_cb_node(cbhead, item);
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02002618 invoke_callback(channel, &item->cq_callback, argv);
2619 free_callback(&item->cq_callback);
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002620 vim_free(item);
2621}
2622
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002623 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002624append_to_buffer(buf_T *buffer, char_u *msg, channel_T *channel, ch_part_T part)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002625{
Bram Moolenaar6b7355a2017-08-04 21:37:54 +02002626 bufref_T save_curbuf = {NULL, 0, 0};
2627 win_T *save_curwin = NULL;
2628 tabpage_T *save_curtab = NULL;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002629 linenr_T lnum = buffer->b_ml.ml_line_count;
2630 int save_write_to = buffer->b_write_to_channel;
Bram Moolenaar9f5842e2016-05-29 16:17:08 +02002631 chanpart_T *ch_part = &channel->ch_part[part];
2632 int save_p_ma = buffer->b_p_ma;
Bram Moolenaarc4da1132017-07-15 19:39:43 +02002633 int empty = (buffer->b_ml.ml_flags & ML_EMPTY) ? 1 : 0;
Bram Moolenaar9f5842e2016-05-29 16:17:08 +02002634
2635 if (!buffer->b_p_ma && !ch_part->ch_nomodifiable)
2636 {
2637 if (!ch_part->ch_nomod_error)
2638 {
2639 ch_error(channel, "Buffer is not modifiable, cannot append");
2640 ch_part->ch_nomod_error = TRUE;
2641 }
2642 return;
2643 }
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002644
Bram Moolenaarc667da52019-11-30 20:52:27 +01002645 // If the buffer is also used as input insert above the last
2646 // line. Don't write these lines.
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002647 if (save_write_to)
2648 {
2649 --lnum;
2650 buffer->b_write_to_channel = FALSE;
2651 }
2652
Bram Moolenaarc667da52019-11-30 20:52:27 +01002653 // Append to the buffer
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002654 ch_log(channel, "appending line %d to buffer", (int)lnum + 1 - empty);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002655
Bram Moolenaar9f5842e2016-05-29 16:17:08 +02002656 buffer->b_p_ma = TRUE;
Bram Moolenaar6b7355a2017-08-04 21:37:54 +02002657
Bram Moolenaarc667da52019-11-30 20:52:27 +01002658 // Save curbuf/curwin/curtab and make "buffer" the current buffer.
Bram Moolenaar6b7355a2017-08-04 21:37:54 +02002659 switch_to_win_for_buf(buffer, &save_curwin, &save_curtab, &save_curbuf);
2660
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002661 u_sync(TRUE);
Bram Moolenaarc667da52019-11-30 20:52:27 +01002662 // ignore undo failure, undo is not very useful here
Bram Moolenaar42335f52018-09-13 15:33:43 +02002663 vim_ignored = u_save(lnum - empty, lnum + 1);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002664
Bram Moolenaar169ebb02016-09-07 23:32:23 +02002665 if (empty)
2666 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002667 // The buffer is empty, replace the first (dummy) line.
Bram Moolenaar169ebb02016-09-07 23:32:23 +02002668 ml_replace(lnum, msg, TRUE);
2669 lnum = 0;
2670 }
2671 else
2672 ml_append(lnum, msg, 0, FALSE);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002673 appended_lines_mark(lnum, 1L);
Bram Moolenaar6b7355a2017-08-04 21:37:54 +02002674
Bram Moolenaarc667da52019-11-30 20:52:27 +01002675 // Restore curbuf/curwin/curtab
Bram Moolenaar6b7355a2017-08-04 21:37:54 +02002676 restore_win_for_buf(save_curwin, save_curtab, &save_curbuf);
2677
Bram Moolenaar9f5842e2016-05-29 16:17:08 +02002678 if (ch_part->ch_nomodifiable)
2679 buffer->b_p_ma = FALSE;
2680 else
2681 buffer->b_p_ma = save_p_ma;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002682
2683 if (buffer->b_nwindows > 0)
2684 {
2685 win_T *wp;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002686
2687 FOR_ALL_WINDOWS(wp)
2688 {
Bram Moolenaar4641a122019-07-29 22:10:23 +02002689 if (wp->w_buffer == buffer)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002690 {
Bram Moolenaar4641a122019-07-29 22:10:23 +02002691 int move_cursor = save_write_to
2692 ? wp->w_cursor.lnum == lnum + 1
2693 : (wp->w_cursor.lnum == lnum
2694 && wp->w_cursor.col == 0);
2695
2696 // If the cursor is at or above the new line, move it one line
2697 // down. If the topline is outdated update it now.
2698 if (move_cursor || wp->w_topline > buffer->b_ml.ml_line_count)
2699 {
2700 if (move_cursor)
2701 ++wp->w_cursor.lnum;
2702 save_curwin = curwin;
2703 curwin = wp;
2704 curbuf = curwin->w_buffer;
2705 scroll_cursor_bot(0, FALSE);
2706 curwin = save_curwin;
2707 curbuf = curwin->w_buffer;
2708 }
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002709 }
2710 }
Bram Moolenaar29ae3772017-04-30 19:39:39 +02002711 redraw_buf_and_status_later(buffer, VALID);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002712 channel_need_redraw = TRUE;
2713 }
2714
2715 if (save_write_to)
2716 {
2717 channel_T *ch;
2718
Bram Moolenaarc667da52019-11-30 20:52:27 +01002719 // Find channels reading from this buffer and adjust their
2720 // next-to-read line number.
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002721 buffer->b_write_to_channel = TRUE;
Bram Moolenaaraeea7212020-04-02 18:50:46 +02002722 FOR_ALL_CHANNELS(ch)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002723 {
2724 chanpart_T *in_part = &ch->ch_part[PART_IN];
2725
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02002726 if (in_part->ch_bufref.br_buf == buffer)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002727 in_part->ch_buf_bot = buffer->b_ml.ml_line_count;
2728 }
2729 }
2730}
2731
Bram Moolenaar437905c2016-04-26 19:01:05 +02002732 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002733drop_messages(channel_T *channel, ch_part_T part)
Bram Moolenaar437905c2016-04-26 19:01:05 +02002734{
2735 char_u *msg;
2736
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002737 while ((msg = channel_get(channel, part, NULL)) != NULL)
Bram Moolenaar437905c2016-04-26 19:01:05 +02002738 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002739 ch_log(channel, "Dropping message '%s'", (char *)msg);
Bram Moolenaar437905c2016-04-26 19:01:05 +02002740 vim_free(msg);
2741 }
2742}
2743
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002744/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002745 * Invoke a callback for "channel"/"part" if needed.
Bram Moolenaar7f7c3322016-04-18 19:27:24 +02002746 * This does not redraw but sets channel_need_redraw when redraw is needed.
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002747 * Return TRUE when a message was handled, there might be another one.
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002748 */
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002749 static int
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002750may_invoke_callback(channel_T *channel, ch_part_T part)
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002751{
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002752 char_u *msg = NULL;
2753 typval_T *listtv = NULL;
Bram Moolenaarece61b02016-02-20 21:39:05 +01002754 typval_T argv[CH_JSON_MAX_ARGS];
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002755 int seq_nr = -1;
Bram Moolenaarec68a992016-10-03 21:37:41 +02002756 chanpart_T *ch_part = &channel->ch_part[part];
2757 ch_mode_T ch_mode = ch_part->ch_mode;
2758 cbq_T *cbhead = &ch_part->ch_cb_head;
Bram Moolenaar5983ad02016-03-05 20:54:36 +01002759 cbq_T *cbitem;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02002760 callback_T *callback = NULL;
Bram Moolenaar187db502016-02-27 14:44:26 +01002761 buf_T *buffer = NULL;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002762 char_u *p;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002763
Bram Moolenaar4e221c92016-02-23 13:20:22 +01002764 if (channel->ch_nb_close_cb != NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002765 // this channel is handled elsewhere (netbeans)
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002766 return FALSE;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002767
Bram Moolenaarc667da52019-11-30 20:52:27 +01002768 // Use a message-specific callback, part callback or channel callback
Bram Moolenaar5983ad02016-03-05 20:54:36 +01002769 for (cbitem = cbhead->cq_next; cbitem != NULL; cbitem = cbitem->cq_next)
2770 if (cbitem->cq_seq_nr == 0)
2771 break;
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002772 if (cbitem != NULL)
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02002773 callback = &cbitem->cq_callback;
2774 else if (ch_part->ch_callback.cb_name != NULL)
2775 callback = &ch_part->ch_callback;
2776 else if (channel->ch_callback.cb_name != NULL)
2777 callback = &channel->ch_callback;
Bram Moolenaarc7f0ebc2016-02-27 21:10:09 +01002778
Bram Moolenaarec68a992016-10-03 21:37:41 +02002779 buffer = ch_part->ch_bufref.br_buf;
Bram Moolenaarc4da1132017-07-15 19:39:43 +02002780 if (buffer != NULL && (!bufref_valid(&ch_part->ch_bufref)
2781 || buffer->b_ml.ml_mfp == NULL))
Bram Moolenaarc7f0ebc2016-02-27 21:10:09 +01002782 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002783 // buffer was wiped out or unloaded
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002784 ch_log(channel, "%s buffer has been wiped out", part_names[part]);
Bram Moolenaarec68a992016-10-03 21:37:41 +02002785 ch_part->ch_bufref.br_buf = NULL;
Bram Moolenaarc7f0ebc2016-02-27 21:10:09 +01002786 buffer = NULL;
2787 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002788
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002789 if (ch_mode == MODE_JSON || ch_mode == MODE_JS)
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002790 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01002791 listitem_T *item;
2792 int argc = 0;
2793
Bram Moolenaarc667da52019-11-30 20:52:27 +01002794 // Get any json message in the queue.
Bram Moolenaar958dc692016-12-01 15:34:12 +01002795 if (channel_get_json(channel, part, -1, FALSE, &listtv) == FAIL)
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002796 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002797 // Parse readahead, return when there is still no message.
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002798 channel_parse_json(channel, part);
Bram Moolenaar958dc692016-12-01 15:34:12 +01002799 if (channel_get_json(channel, part, -1, FALSE, &listtv) == FAIL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01002800 return FALSE;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002801 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002802
Bram Moolenaarece61b02016-02-20 21:39:05 +01002803 for (item = listtv->vval.v_list->lv_first;
2804 item != NULL && argc < CH_JSON_MAX_ARGS;
2805 item = item->li_next)
2806 argv[argc++] = item->li_tv;
2807 while (argc < CH_JSON_MAX_ARGS)
2808 argv[argc++].v_type = VAR_UNKNOWN;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002809
Bram Moolenaarece61b02016-02-20 21:39:05 +01002810 if (argv[0].v_type == VAR_STRING)
2811 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002812 // ["cmd", arg] or ["cmd", arg, arg] or ["cmd", arg, arg, arg]
Bram Moolenaarece61b02016-02-20 21:39:05 +01002813 channel_exe_cmd(channel, part, argv);
Bram Moolenaar77073442016-02-13 23:23:53 +01002814 free_tv(listtv);
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002815 return TRUE;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002816 }
2817
Bram Moolenaarece61b02016-02-20 21:39:05 +01002818 if (argv[0].v_type != VAR_NUMBER)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002819 {
Bram Moolenaar77073442016-02-13 23:23:53 +01002820 ch_error(channel,
Bram Moolenaar81661fb2016-02-18 22:23:34 +01002821 "Dropping message with invalid sequence number type");
Bram Moolenaar77073442016-02-13 23:23:53 +01002822 free_tv(listtv);
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002823 return FALSE;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002824 }
Bram Moolenaarece61b02016-02-20 21:39:05 +01002825 seq_nr = argv[0].vval.v_number;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002826 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002827 else if (channel_peek(channel, part) == NULL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01002828 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002829 // nothing to read on RAW or NL channel
Bram Moolenaard7ece102016-02-02 23:23:02 +01002830 return FALSE;
2831 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002832 else
2833 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002834 // If there is no callback or buffer drop the message.
Bram Moolenaar187db502016-02-27 14:44:26 +01002835 if (callback == NULL && buffer == NULL)
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002836 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002837 // If there is a close callback it may use ch_read() to get the
2838 // messages.
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02002839 if (channel->ch_close_cb.cb_name == NULL && !channel->ch_drop_never)
Bram Moolenaar437905c2016-04-26 19:01:05 +02002840 drop_messages(channel, part);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002841 return FALSE;
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002842 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002843
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002844 if (ch_mode == MODE_NL)
2845 {
Bram Moolenaarec68a992016-10-03 21:37:41 +02002846 char_u *nl = NULL;
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002847 char_u *buf;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002848 readq_T *node;
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002849
Bram Moolenaarc667da52019-11-30 20:52:27 +01002850 // See if we have a message ending in NL in the first buffer. If
2851 // not try to concatenate the first and the second buffer.
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002852 while (TRUE)
2853 {
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002854 node = channel_peek(channel, part);
2855 nl = channel_first_nl(node);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002856 if (nl != NULL)
2857 break;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02002858 if (channel_collapse(channel, part, TRUE) == FAIL)
Bram Moolenaarec68a992016-10-03 21:37:41 +02002859 {
2860 if (ch_part->ch_fd == INVALID_FD && node->rq_buflen > 0)
2861 break;
Bram Moolenaarc667da52019-11-30 20:52:27 +01002862 return FALSE; // incomplete message
Bram Moolenaarec68a992016-10-03 21:37:41 +02002863 }
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002864 }
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002865 buf = node->rq_buffer;
2866
Bram Moolenaar772153f2019-03-04 12:09:49 +01002867 // Convert NUL to NL, the internal representation.
2868 for (p = buf; (nl == NULL || p < nl)
2869 && p < buf + node->rq_buflen; ++p)
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002870 if (*p == NUL)
2871 *p = NL;
2872
Bram Moolenaar772153f2019-03-04 12:09:49 +01002873 if (nl == NULL)
Bram Moolenaar187db502016-02-27 14:44:26 +01002874 {
Bram Moolenaar772153f2019-03-04 12:09:49 +01002875 // get the whole buffer, drop the NL
2876 msg = channel_get(channel, part, NULL);
2877 }
2878 else if (nl + 1 == buf + node->rq_buflen)
2879 {
2880 // get the whole buffer
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002881 msg = channel_get(channel, part, NULL);
Bram Moolenaar187db502016-02-27 14:44:26 +01002882 *nl = NUL;
2883 }
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002884 else
2885 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002886 // Copy the message into allocated memory (excluding the NL)
2887 // and remove it from the buffer (including the NL).
Bram Moolenaardf44a272020-06-07 20:49:05 +02002888 msg = vim_strnsave(buf, nl - buf);
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002889 channel_consume(channel, part, (int)(nl - buf) + 1);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002890 }
2891 }
2892 else
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002893 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002894 // For a raw channel we don't know where the message ends, just
2895 // get everything we have.
2896 // Convert NUL to NL, the internal representation.
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002897 msg = channel_get_all(channel, part, NULL);
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002898 }
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002899
Bram Moolenaarbf73b912016-03-02 21:16:59 +01002900 if (msg == NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002901 return FALSE; // out of memory (and avoids Coverity warning)
Bram Moolenaarbf73b912016-03-02 21:16:59 +01002902
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002903 argv[1].v_type = VAR_STRING;
2904 argv[1].vval.v_string = msg;
2905 }
2906
Bram Moolenaara07fec92016-02-05 21:04:08 +01002907 if (seq_nr > 0)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002908 {
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002909 int done = FALSE;
Bram Moolenaara07fec92016-02-05 21:04:08 +01002910
Bram Moolenaarc667da52019-11-30 20:52:27 +01002911 // JSON or JS mode: invoke the one-time callback with the matching nr
Bram Moolenaar5983ad02016-03-05 20:54:36 +01002912 for (cbitem = cbhead->cq_next; cbitem != NULL; cbitem = cbitem->cq_next)
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002913 if (cbitem->cq_seq_nr == seq_nr)
Bram Moolenaara07fec92016-02-05 21:04:08 +01002914 {
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002915 invoke_one_time_callback(channel, cbhead, cbitem, argv);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002916 done = TRUE;
Bram Moolenaara07fec92016-02-05 21:04:08 +01002917 break;
2918 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002919 if (!done)
Bram Moolenaar958dc692016-12-01 15:34:12 +01002920 {
2921 if (channel->ch_drop_never)
2922 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002923 // message must be read with ch_read()
Bram Moolenaar958dc692016-12-01 15:34:12 +01002924 channel_push_json(channel, part, listtv);
2925 listtv = NULL;
2926 }
2927 else
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002928 ch_log(channel, "Dropping message %d without callback",
Bram Moolenaar958dc692016-12-01 15:34:12 +01002929 seq_nr);
2930 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002931 }
Bram Moolenaar187db502016-02-27 14:44:26 +01002932 else if (callback != NULL || buffer != NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002933 {
Bram Moolenaar187db502016-02-27 14:44:26 +01002934 if (buffer != NULL)
2935 {
Bram Moolenaarcc7f8be2016-02-29 22:55:56 +01002936 if (msg == NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002937 // JSON or JS mode: re-encode the message.
Bram Moolenaarcc7f8be2016-02-29 22:55:56 +01002938 msg = json_encode(listtv, ch_mode);
2939 if (msg != NULL)
Bram Moolenaarcb8bbe92017-07-16 13:48:22 +02002940 {
Bram Moolenaarc0aa4822017-07-16 14:04:29 +02002941#ifdef FEAT_TERMINAL
Bram Moolenaarcb8bbe92017-07-16 13:48:22 +02002942 if (buffer->b_term != NULL)
2943 write_to_term(buffer, msg, channel);
2944 else
Bram Moolenaarc0aa4822017-07-16 14:04:29 +02002945#endif
Bram Moolenaarcb8bbe92017-07-16 13:48:22 +02002946 append_to_buffer(buffer, msg, channel, part);
2947 }
Bram Moolenaar187db502016-02-27 14:44:26 +01002948 }
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002949
Bram Moolenaar187db502016-02-27 14:44:26 +01002950 if (callback != NULL)
2951 {
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002952 if (cbitem != NULL)
2953 invoke_one_time_callback(channel, cbhead, cbitem, argv);
2954 else
2955 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002956 // invoke the channel callback
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002957 ch_log(channel, "Invoking channel callback %s",
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02002958 (char *)callback->cb_name);
2959 invoke_callback(channel, callback, argv);
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002960 }
Bram Moolenaar187db502016-02-27 14:44:26 +01002961 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002962 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002963 else
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002964 ch_log(channel, "Dropping message %d", seq_nr);
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002965
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002966 if (listtv != NULL)
Bram Moolenaar77073442016-02-13 23:23:53 +01002967 free_tv(listtv);
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002968 vim_free(msg);
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002969
2970 return TRUE;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002971}
2972
Bram Moolenaar113e1072019-01-20 15:30:40 +01002973#if defined(FEAT_NETBEANS_INTG) || defined(PROTO)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002974/*
Bram Moolenaar77073442016-02-13 23:23:53 +01002975 * Return TRUE when channel "channel" is open for writing to.
2976 * Also returns FALSE or invalid "channel".
Bram Moolenaard04a0202016-01-26 23:30:18 +01002977 */
2978 int
Bram Moolenaar77073442016-02-13 23:23:53 +01002979channel_can_write_to(channel_T *channel)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002980{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002981 return channel != NULL && (channel->CH_SOCK_FD != INVALID_FD
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01002982 || channel->CH_IN_FD != INVALID_FD);
Bram Moolenaard04a0202016-01-26 23:30:18 +01002983}
Bram Moolenaar113e1072019-01-20 15:30:40 +01002984#endif
Bram Moolenaard04a0202016-01-26 23:30:18 +01002985
2986/*
Bram Moolenaar77073442016-02-13 23:23:53 +01002987 * Return TRUE when channel "channel" is open for reading or writing.
2988 * Also returns FALSE for invalid "channel".
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002989 */
2990 int
Bram Moolenaar77073442016-02-13 23:23:53 +01002991channel_is_open(channel_T *channel)
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002992{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002993 return channel != NULL && (channel->CH_SOCK_FD != INVALID_FD
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002994 || channel->CH_IN_FD != INVALID_FD
2995 || channel->CH_OUT_FD != INVALID_FD
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01002996 || channel->CH_ERR_FD != INVALID_FD);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002997}
2998
2999/*
Bram Moolenaar437905c2016-04-26 19:01:05 +02003000 * Return TRUE if "channel" has JSON or other typeahead.
3001 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02003002 static int
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003003channel_has_readahead(channel_T *channel, ch_part_T part)
Bram Moolenaar437905c2016-04-26 19:01:05 +02003004{
3005 ch_mode_T ch_mode = channel->ch_part[part].ch_mode;
3006
3007 if (ch_mode == MODE_JSON || ch_mode == MODE_JS)
3008 {
3009 jsonq_T *head = &channel->ch_part[part].ch_json_head;
Bram Moolenaar437905c2016-04-26 19:01:05 +02003010
Bram Moolenaar4340fc92019-06-28 22:06:49 +02003011 if (head->jq_next == NULL)
3012 // Parse json from readahead, there might be a complete message to
3013 // process.
3014 channel_parse_json(channel, part);
3015
3016 return head->jq_next != NULL;
Bram Moolenaar437905c2016-04-26 19:01:05 +02003017 }
3018 return channel_peek(channel, part) != NULL;
3019}
3020
3021/*
Bram Moolenaar77073442016-02-13 23:23:53 +01003022 * Return a string indicating the status of the channel.
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003023 * If "req_part" is not negative check that part.
Bram Moolenaar77073442016-02-13 23:23:53 +01003024 */
3025 char *
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003026channel_status(channel_T *channel, int req_part)
Bram Moolenaar77073442016-02-13 23:23:53 +01003027{
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003028 ch_part_T part;
Bram Moolenaar437905c2016-04-26 19:01:05 +02003029 int has_readahead = FALSE;
3030
Bram Moolenaar77073442016-02-13 23:23:53 +01003031 if (channel == NULL)
3032 return "fail";
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003033 if (req_part == PART_OUT)
3034 {
3035 if (channel->CH_OUT_FD != INVALID_FD)
3036 return "open";
3037 if (channel_has_readahead(channel, PART_OUT))
Bram Moolenaar437905c2016-04-26 19:01:05 +02003038 has_readahead = TRUE;
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003039 }
3040 else if (req_part == PART_ERR)
3041 {
3042 if (channel->CH_ERR_FD != INVALID_FD)
3043 return "open";
3044 if (channel_has_readahead(channel, PART_ERR))
3045 has_readahead = TRUE;
3046 }
3047 else
3048 {
3049 if (channel_is_open(channel))
3050 return "open";
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003051 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003052 if (channel_has_readahead(channel, part))
3053 {
3054 has_readahead = TRUE;
3055 break;
3056 }
3057 }
Bram Moolenaar437905c2016-04-26 19:01:05 +02003058
3059 if (has_readahead)
3060 return "buffered";
Bram Moolenaar77073442016-02-13 23:23:53 +01003061 return "closed";
3062}
3063
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003064 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003065channel_part_info(channel_T *channel, dict_T *dict, char *name, ch_part_T part)
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003066{
3067 chanpart_T *chanpart = &channel->ch_part[part];
Bram Moolenaarc667da52019-11-30 20:52:27 +01003068 char namebuf[20]; // longest is "sock_timeout"
Bram Moolenaar3f3fbd32016-03-21 12:36:28 +01003069 size_t tail;
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003070 char *status;
Bram Moolenaar573e4452016-03-21 22:35:10 +01003071 char *s = "";
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003072
Bram Moolenaar925ccfd2016-03-28 22:38:02 +02003073 vim_strncpy((char_u *)namebuf, (char_u *)name, 4);
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003074 STRCAT(namebuf, "_");
3075 tail = STRLEN(namebuf);
3076
3077 STRCPY(namebuf + tail, "status");
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003078 if (chanpart->ch_fd != INVALID_FD)
3079 status = "open";
3080 else if (channel_has_readahead(channel, part))
3081 status = "buffered";
3082 else
3083 status = "closed";
Bram Moolenaare0be1672018-07-08 16:50:37 +02003084 dict_add_string(dict, namebuf, (char_u *)status);
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003085
3086 STRCPY(namebuf + tail, "mode");
3087 switch (chanpart->ch_mode)
3088 {
3089 case MODE_NL: s = "NL"; break;
3090 case MODE_RAW: s = "RAW"; break;
3091 case MODE_JSON: s = "JSON"; break;
3092 case MODE_JS: s = "JS"; break;
3093 }
Bram Moolenaare0be1672018-07-08 16:50:37 +02003094 dict_add_string(dict, namebuf, (char_u *)s);
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003095
3096 STRCPY(namebuf + tail, "io");
3097 if (part == PART_SOCK)
3098 s = "socket";
3099 else switch (chanpart->ch_io)
3100 {
3101 case JIO_NULL: s = "null"; break;
3102 case JIO_PIPE: s = "pipe"; break;
3103 case JIO_FILE: s = "file"; break;
3104 case JIO_BUFFER: s = "buffer"; break;
3105 case JIO_OUT: s = "out"; break;
3106 }
Bram Moolenaare0be1672018-07-08 16:50:37 +02003107 dict_add_string(dict, namebuf, (char_u *)s);
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003108
3109 STRCPY(namebuf + tail, "timeout");
Bram Moolenaare0be1672018-07-08 16:50:37 +02003110 dict_add_number(dict, namebuf, chanpart->ch_timeout);
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003111}
3112
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02003113 static void
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003114channel_info(channel_T *channel, dict_T *dict)
3115{
Bram Moolenaare0be1672018-07-08 16:50:37 +02003116 dict_add_number(dict, "id", channel->ch_id);
3117 dict_add_string(dict, "status", (char_u *)channel_status(channel, -1));
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003118
3119 if (channel->ch_hostname != NULL)
3120 {
Bram Moolenaare0be1672018-07-08 16:50:37 +02003121 dict_add_string(dict, "hostname", (char_u *)channel->ch_hostname);
3122 dict_add_number(dict, "port", channel->ch_port);
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003123 channel_part_info(channel, dict, "sock", PART_SOCK);
3124 }
3125 else
3126 {
3127 channel_part_info(channel, dict, "out", PART_OUT);
3128 channel_part_info(channel, dict, "err", PART_ERR);
3129 channel_part_info(channel, dict, "in", PART_IN);
3130 }
3131}
3132
Bram Moolenaar77073442016-02-13 23:23:53 +01003133/*
3134 * Close channel "channel".
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +01003135 * Trigger the close callback if "invoke_close_cb" is TRUE.
Bram Moolenaar187db502016-02-27 14:44:26 +01003136 * Does not clear the buffers.
Bram Moolenaard04a0202016-01-26 23:30:18 +01003137 */
3138 void
Bram Moolenaar8b374212016-02-24 20:43:06 +01003139channel_close(channel_T *channel, int invoke_close_cb)
Bram Moolenaard04a0202016-01-26 23:30:18 +01003140{
Bram Moolenaar81661fb2016-02-18 22:23:34 +01003141 ch_log(channel, "Closing channel");
Bram Moolenaard04a0202016-01-26 23:30:18 +01003142
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01003143#ifdef FEAT_GUI
3144 channel_gui_unregister(channel);
3145#endif
3146
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003147 ch_close_part(channel, PART_SOCK);
3148 ch_close_part(channel, PART_IN);
3149 ch_close_part(channel, PART_OUT);
3150 ch_close_part(channel, PART_ERR);
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01003151
Bram Moolenaara9f02812017-08-05 17:40:38 +02003152 if (invoke_close_cb)
Bram Moolenaar4e221c92016-02-23 13:20:22 +01003153 {
Bram Moolenaara9f02812017-08-05 17:40:38 +02003154 ch_part_T part;
Bram Moolenaar4e221c92016-02-23 13:20:22 +01003155
Bram Moolenaarc667da52019-11-30 20:52:27 +01003156 // Invoke callbacks and flush buffers before the close callback.
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003157 if (channel->ch_close_cb.cb_name != NULL)
Bram Moolenaara9f02812017-08-05 17:40:38 +02003158 ch_log(channel,
3159 "Invoking callbacks and flushing buffers before closing");
3160 for (part = PART_SOCK; part < PART_IN; ++part)
3161 {
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003162 if (channel->ch_close_cb.cb_name != NULL
Bram Moolenaara9f02812017-08-05 17:40:38 +02003163 || channel->ch_part[part].ch_bufref.br_buf != NULL)
3164 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01003165 // Increment the refcount to avoid the channel being freed
3166 // halfway.
Bram Moolenaara9f02812017-08-05 17:40:38 +02003167 ++channel->ch_refcount;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003168 if (channel->ch_close_cb.cb_name == NULL)
Bram Moolenaara9f02812017-08-05 17:40:38 +02003169 ch_log(channel, "flushing %s buffers before closing",
3170 part_names[part]);
3171 while (may_invoke_callback(channel, part))
3172 ;
3173 --channel->ch_refcount;
3174 }
3175 }
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003176
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003177 if (channel->ch_close_cb.cb_name != NULL)
Bram Moolenaara9f02812017-08-05 17:40:38 +02003178 {
3179 typval_T argv[1];
3180 typval_T rettv;
Bram Moolenaara9f02812017-08-05 17:40:38 +02003181
Bram Moolenaarc667da52019-11-30 20:52:27 +01003182 // Increment the refcount to avoid the channel being freed
3183 // halfway.
Bram Moolenaara9f02812017-08-05 17:40:38 +02003184 ++channel->ch_refcount;
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003185 ch_log(channel, "Invoking close callback %s",
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003186 (char *)channel->ch_close_cb.cb_name);
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003187 argv[0].v_type = VAR_CHANNEL;
3188 argv[0].vval.v_channel = channel;
Bram Moolenaarc6538bc2019-08-03 18:17:11 +02003189 call_callback(&channel->ch_close_cb, -1, &rettv, 1, argv);
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003190 clear_tv(&rettv);
Bram Moolenaarcefe4f92016-05-04 21:49:19 +02003191 channel_need_redraw = TRUE;
Bram Moolenaar4e221c92016-02-23 13:20:22 +01003192
Bram Moolenaarc667da52019-11-30 20:52:27 +01003193 // the callback is only called once
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003194 free_callback(&channel->ch_close_cb);
Bram Moolenaar437905c2016-04-26 19:01:05 +02003195
Bram Moolenaara9f02812017-08-05 17:40:38 +02003196 if (channel_need_redraw)
3197 {
3198 channel_need_redraw = FALSE;
Bram Moolenaar02e177d2017-08-26 23:43:28 +02003199 redraw_after_callback(TRUE);
Bram Moolenaara9f02812017-08-05 17:40:38 +02003200 }
Bram Moolenaarcefe4f92016-05-04 21:49:19 +02003201
Bram Moolenaara9f02812017-08-05 17:40:38 +02003202 if (!channel->ch_drop_never)
Bram Moolenaarc667da52019-11-30 20:52:27 +01003203 // any remaining messages are useless now
Bram Moolenaara9f02812017-08-05 17:40:38 +02003204 for (part = PART_SOCK; part < PART_IN; ++part)
3205 drop_messages(channel, part);
Bram Moolenaar5fd8b782017-11-11 15:54:00 +01003206
3207 --channel->ch_refcount;
Bram Moolenaara9f02812017-08-05 17:40:38 +02003208 }
Bram Moolenaar4e221c92016-02-23 13:20:22 +01003209 }
3210
3211 channel->ch_nb_close_cb = NULL;
Bram Moolenaard85f2712017-07-28 21:51:57 +02003212
3213#ifdef FEAT_TERMINAL
3214 term_channel_closed(channel);
3215#endif
Bram Moolenaare0874f82016-01-24 20:36:41 +01003216}
3217
Bram Moolenaard04a0202016-01-26 23:30:18 +01003218/*
Bram Moolenaar0874a832016-09-01 15:11:51 +02003219 * Close the "in" part channel "channel".
3220 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02003221 static void
Bram Moolenaar0874a832016-09-01 15:11:51 +02003222channel_close_in(channel_T *channel)
3223{
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003224 ch_close_part(channel, PART_IN);
Bram Moolenaar0874a832016-09-01 15:11:51 +02003225}
3226
Bram Moolenaaraba680a2017-09-09 16:42:53 +02003227 static void
3228remove_from_writeque(writeq_T *wq, writeq_T *entry)
3229{
3230 ga_clear(&entry->wq_ga);
3231 wq->wq_next = entry->wq_next;
3232 if (wq->wq_next == NULL)
3233 wq->wq_prev = NULL;
3234 else
3235 wq->wq_next->wq_prev = NULL;
Bram Moolenaar5b5adf52017-09-09 18:16:43 +02003236 vim_free(entry);
Bram Moolenaaraba680a2017-09-09 16:42:53 +02003237}
3238
Bram Moolenaar0874a832016-09-01 15:11:51 +02003239/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003240 * Clear the read buffer on "channel"/"part".
Bram Moolenaard04a0202016-01-26 23:30:18 +01003241 */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003242 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003243channel_clear_one(channel_T *channel, ch_part_T part)
Bram Moolenaard04a0202016-01-26 23:30:18 +01003244{
Bram Moolenaaraba680a2017-09-09 16:42:53 +02003245 chanpart_T *ch_part = &channel->ch_part[part];
3246 jsonq_T *json_head = &ch_part->ch_json_head;
3247 cbq_T *cb_head = &ch_part->ch_cb_head;
Bram Moolenaard04a0202016-01-26 23:30:18 +01003248
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003249 while (channel_peek(channel, part) != NULL)
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003250 vim_free(channel_get(channel, part, NULL));
Bram Moolenaar77073442016-02-13 23:23:53 +01003251
3252 while (cb_head->cq_next != NULL)
Bram Moolenaard46ae142016-02-16 13:33:52 +01003253 {
3254 cbq_T *node = cb_head->cq_next;
3255
3256 remove_cb_node(cb_head, node);
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003257 free_callback(&node->cq_callback);
Bram Moolenaard46ae142016-02-16 13:33:52 +01003258 vim_free(node);
3259 }
Bram Moolenaar77073442016-02-13 23:23:53 +01003260
3261 while (json_head->jq_next != NULL)
Bram Moolenaard04a0202016-01-26 23:30:18 +01003262 {
Bram Moolenaar77073442016-02-13 23:23:53 +01003263 free_tv(json_head->jq_next->jq_value);
3264 remove_json_node(json_head, json_head->jq_next);
Bram Moolenaard04a0202016-01-26 23:30:18 +01003265 }
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01003266
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003267 free_callback(&ch_part->ch_callback);
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003268 ga_clear(&ch_part->ch_block_ids);
Bram Moolenaaraba680a2017-09-09 16:42:53 +02003269
3270 while (ch_part->ch_writeque.wq_next != NULL)
3271 remove_from_writeque(&ch_part->ch_writeque,
3272 ch_part->ch_writeque.wq_next);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003273}
3274
3275/*
3276 * Clear all the read buffers on "channel".
3277 */
3278 void
3279channel_clear(channel_T *channel)
3280{
Bram Moolenaard6051b52016-02-28 15:49:03 +01003281 ch_log(channel, "Clearing channel");
Bram Moolenaard23a8232018-02-10 18:45:26 +01003282 VIM_CLEAR(channel->ch_hostname);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003283 channel_clear_one(channel, PART_SOCK);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003284 channel_clear_one(channel, PART_OUT);
3285 channel_clear_one(channel, PART_ERR);
Bram Moolenaar5b5adf52017-09-09 18:16:43 +02003286 channel_clear_one(channel, PART_IN);
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003287 free_callback(&channel->ch_callback);
3288 free_callback(&channel->ch_close_cb);
Bram Moolenaard04a0202016-01-26 23:30:18 +01003289}
3290
Bram Moolenaar77073442016-02-13 23:23:53 +01003291#if defined(EXITFREE) || defined(PROTO)
3292 void
3293channel_free_all(void)
3294{
3295 channel_T *channel;
3296
Bram Moolenaard6051b52016-02-28 15:49:03 +01003297 ch_log(NULL, "channel_free_all()");
Bram Moolenaaraeea7212020-04-02 18:50:46 +02003298 FOR_ALL_CHANNELS(channel)
Bram Moolenaar77073442016-02-13 23:23:53 +01003299 channel_clear(channel);
3300}
3301#endif
3302
3303
Bram Moolenaarc667da52019-11-30 20:52:27 +01003304// Sent when the netbeans channel is found closed when reading.
Bram Moolenaareed284a2016-02-22 23:13:33 +01003305#define DETACH_MSG_RAW "DETACH\n"
Bram Moolenaard04a0202016-01-26 23:30:18 +01003306
Bram Moolenaarc667da52019-11-30 20:52:27 +01003307// Buffer size for reading incoming messages.
Bram Moolenaard04a0202016-01-26 23:30:18 +01003308#define MAXMSGSIZE 4096
3309
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003310#if defined(HAVE_SELECT)
3311/*
3312 * Add write fds where we are waiting for writing to be possible.
3313 */
3314 static int
3315channel_fill_wfds(int maxfd_arg, fd_set *wfds)
3316{
3317 int maxfd = maxfd_arg;
3318 channel_T *ch;
3319
Bram Moolenaaraeea7212020-04-02 18:50:46 +02003320 FOR_ALL_CHANNELS(ch)
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003321 {
3322 chanpart_T *in_part = &ch->ch_part[PART_IN];
3323
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02003324 if (in_part->ch_fd != INVALID_FD
3325 && (in_part->ch_bufref.br_buf != NULL
3326 || in_part->ch_writeque.wq_next != NULL))
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003327 {
3328 FD_SET((int)in_part->ch_fd, wfds);
3329 if ((int)in_part->ch_fd >= maxfd)
3330 maxfd = (int)in_part->ch_fd + 1;
3331 }
3332 }
3333 return maxfd;
3334}
3335#else
3336/*
3337 * Add write fds where we are waiting for writing to be possible.
3338 */
3339 static int
3340channel_fill_poll_write(int nfd_in, struct pollfd *fds)
3341{
3342 int nfd = nfd_in;
3343 channel_T *ch;
3344
Bram Moolenaaraeea7212020-04-02 18:50:46 +02003345 FOR_ALL_CHANNELS(ch)
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003346 {
3347 chanpart_T *in_part = &ch->ch_part[PART_IN];
3348
Bram Moolenaar683b7962017-08-19 15:51:59 +02003349 if (in_part->ch_fd != INVALID_FD
3350 && (in_part->ch_bufref.br_buf != NULL
3351 || in_part->ch_writeque.wq_next != NULL))
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003352 {
3353 in_part->ch_poll_idx = nfd;
3354 fds[nfd].fd = in_part->ch_fd;
3355 fds[nfd].events = POLLOUT;
3356 ++nfd;
3357 }
3358 else
3359 in_part->ch_poll_idx = -1;
3360 }
3361 return nfd;
3362}
3363#endif
3364
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003365typedef enum {
3366 CW_READY,
3367 CW_NOT_READY,
3368 CW_ERROR
3369} channel_wait_result;
3370
Bram Moolenaard04a0202016-01-26 23:30:18 +01003371/*
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003372 * Check for reading from "fd" with "timeout" msec.
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003373 * Return CW_READY when there is something to read.
3374 * Return CW_NOT_READY when there is nothing to read.
3375 * Return CW_ERROR when there is an error.
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003376 */
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003377 static channel_wait_result
Bram Moolenaard8070362016-02-15 21:56:54 +01003378channel_wait(channel_T *channel, sock_T fd, int timeout)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003379{
Bram Moolenaar6463ca22016-02-13 17:04:46 +01003380 if (timeout > 0)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003381 ch_log(channel, "Waiting for up to %d msec", timeout);
Bram Moolenaard8070362016-02-15 21:56:54 +01003382
Bram Moolenaar4f974752019-02-17 17:44:42 +01003383# ifdef MSWIN
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003384 if (fd != channel->CH_SOCK_FD)
Bram Moolenaard8070362016-02-15 21:56:54 +01003385 {
3386 DWORD nread;
Bram Moolenaar84e1d2b2016-03-28 14:20:41 +02003387 int sleep_time;
Bram Moolenaard8070362016-02-15 21:56:54 +01003388 DWORD deadline = GetTickCount() + timeout;
Bram Moolenaar84e1d2b2016-03-28 14:20:41 +02003389 int delay = 1;
Bram Moolenaard8070362016-02-15 21:56:54 +01003390
Bram Moolenaarc667da52019-11-30 20:52:27 +01003391 // reading from a pipe, not a socket
Bram Moolenaard8070362016-02-15 21:56:54 +01003392 while (TRUE)
3393 {
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003394 int r = PeekNamedPipe((HANDLE)fd, NULL, 0, NULL, &nread, NULL);
3395
3396 if (r && nread > 0)
3397 return CW_READY;
Bram Moolenaar31faed62019-01-22 23:01:40 +01003398
3399 if (channel->ch_named_pipe)
3400 {
3401 DisconnectNamedPipe((HANDLE)fd);
3402 ConnectNamedPipe((HANDLE)fd, NULL);
3403 }
3404 else if (r == 0)
Bram Moolenaarb091f302019-01-19 14:37:00 +01003405 return CW_ERROR;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003406
Bram Moolenaarc667da52019-11-30 20:52:27 +01003407 // perhaps write some buffer lines
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003408 channel_write_any_lines();
3409
Bram Moolenaar84e1d2b2016-03-28 14:20:41 +02003410 sleep_time = deadline - GetTickCount();
3411 if (sleep_time <= 0)
Bram Moolenaard8070362016-02-15 21:56:54 +01003412 break;
Bram Moolenaarc667da52019-11-30 20:52:27 +01003413 // Wait for a little while. Very short at first, up to 10 msec
3414 // after looping a few times.
Bram Moolenaar84e1d2b2016-03-28 14:20:41 +02003415 if (sleep_time > delay)
3416 sleep_time = delay;
3417 Sleep(sleep_time);
3418 delay = delay * 2;
3419 if (delay > 10)
3420 delay = 10;
Bram Moolenaard8070362016-02-15 21:56:54 +01003421 }
Bram Moolenaard8070362016-02-15 21:56:54 +01003422 }
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003423 else
Bram Moolenaard8070362016-02-15 21:56:54 +01003424#endif
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003425 {
Bram Moolenaar9186a272016-02-23 19:34:01 +01003426#if defined(HAVE_SELECT)
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003427 struct timeval tval;
3428 fd_set rfds;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003429 fd_set wfds;
3430 int ret;
3431 int maxfd;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003432
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003433 tval.tv_sec = timeout / 1000;
3434 tval.tv_usec = (timeout % 1000) * 1000;
3435 for (;;)
3436 {
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003437 FD_ZERO(&rfds);
3438 FD_SET((int)fd, &rfds);
3439
Bram Moolenaarc667da52019-11-30 20:52:27 +01003440 // Write lines to a pipe when a pipe can be written to. Need to
3441 // set this every time, some buffers may be done.
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003442 maxfd = (int)fd + 1;
3443 FD_ZERO(&wfds);
3444 maxfd = channel_fill_wfds(maxfd, &wfds);
3445
3446 ret = select(maxfd, &rfds, &wfds, NULL, &tval);
Bram Moolenaar9186a272016-02-23 19:34:01 +01003447# ifdef EINTR
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003448 SOCK_ERRNO;
3449 if (ret == -1 && errno == EINTR)
3450 continue;
Bram Moolenaar9186a272016-02-23 19:34:01 +01003451# endif
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003452 if (ret > 0)
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003453 {
3454 if (FD_ISSET(fd, &rfds))
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003455 return CW_READY;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003456 channel_write_any_lines();
3457 continue;
3458 }
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003459 break;
3460 }
Bram Moolenaar9186a272016-02-23 19:34:01 +01003461#else
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003462 for (;;)
3463 {
3464 struct pollfd fds[MAX_OPEN_CHANNELS + 1];
3465 int nfd = 1;
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003466
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003467 fds[0].fd = fd;
3468 fds[0].events = POLLIN;
3469 nfd = channel_fill_poll_write(nfd, fds);
3470 if (poll(fds, nfd, timeout) > 0)
3471 {
3472 if (fds[0].revents & POLLIN)
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003473 return CW_READY;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003474 channel_write_any_lines();
3475 continue;
3476 }
3477 break;
3478 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003479#endif
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003480 }
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003481 return CW_NOT_READY;
3482}
3483
3484 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003485ch_close_part_on_error(
3486 channel_T *channel, ch_part_T part, int is_err, char *func)
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003487{
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003488 char msg[] = "%s(): Read %s from ch_part[%d], closing";
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003489
3490 if (is_err)
Bram Moolenaarc667da52019-11-30 20:52:27 +01003491 // Do not call emsg(), most likely the other end just exited.
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003492 ch_error(channel, msg, func, "error", part);
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003493 else
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003494 ch_log(channel, msg, func, "EOF", part);
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003495
Bram Moolenaarc667da52019-11-30 20:52:27 +01003496 // Queue a "DETACH" netbeans message in the command queue in order to
3497 // terminate the netbeans session later. Do not end the session here
3498 // directly as we may be running in the context of a call to
3499 // netbeans_parse_messages():
3500 // netbeans_parse_messages
3501 // -> autocmd triggered while processing the netbeans cmd
3502 // -> ui_breakcheck
3503 // -> gui event loop or select loop
3504 // -> channel_read()
3505 // Only send "DETACH" for a netbeans channel.
Bram Moolenaar715d2852016-04-30 17:06:31 +02003506 if (channel->ch_nb_close_cb != NULL)
Bram Moolenaar8ddef482016-10-09 15:43:25 +02003507 channel_save(channel, PART_SOCK, (char_u *)DETACH_MSG_RAW,
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003508 (int)STRLEN(DETACH_MSG_RAW), FALSE, "PUT ");
3509
Bram Moolenaarc667da52019-11-30 20:52:27 +01003510 // When reading is not possible close this part of the channel. Don't
3511 // close the channel yet, there may be something to read on another part.
3512 // When stdout and stderr use the same FD we get the error only on one of
3513 // them, also close the other.
Bram Moolenaarb0b98d52018-05-05 21:01:00 +02003514 if (part == PART_OUT || part == PART_ERR)
3515 {
3516 ch_part_T other = part == PART_OUT ? PART_ERR : PART_OUT;
3517
3518 if (channel->ch_part[part].ch_fd == channel->ch_part[other].ch_fd)
3519 ch_close_part(channel, other);
3520 }
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003521 ch_close_part(channel, part);
Bram Moolenaarbf981ee2016-05-28 13:20:31 +02003522
3523#ifdef FEAT_GUI
Bram Moolenaarc667da52019-11-30 20:52:27 +01003524 // Stop listening to GUI events right away.
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003525 channel_gui_unregister_one(channel, part);
Bram Moolenaarbf981ee2016-05-28 13:20:31 +02003526#endif
Bram Moolenaarcf7ff702016-05-09 17:20:14 +02003527}
3528
3529 static void
3530channel_close_now(channel_T *channel)
3531{
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003532 ch_log(channel, "Closing channel because all readable fds are closed");
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003533 if (channel->ch_nb_close_cb != NULL)
3534 (*channel->ch_nb_close_cb)();
Bram Moolenaar958dc692016-12-01 15:34:12 +01003535 channel_close(channel, TRUE);
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003536}
3537
3538/*
Bram Moolenaar77073442016-02-13 23:23:53 +01003539 * Read from channel "channel" for as long as there is something to read.
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003540 * "part" is PART_SOCK, PART_OUT or PART_ERR.
Bram Moolenaar655da312016-05-28 22:22:34 +02003541 * The data is put in the read queue. No callbacks are invoked here.
Bram Moolenaard04a0202016-01-26 23:30:18 +01003542 */
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003543 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003544channel_read(channel_T *channel, ch_part_T part, char *func)
Bram Moolenaard04a0202016-01-26 23:30:18 +01003545{
3546 static char_u *buf = NULL;
3547 int len = 0;
3548 int readlen = 0;
Bram Moolenaard8070362016-02-15 21:56:54 +01003549 sock_T fd;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01003550 int use_socket = FALSE;
Bram Moolenaard04a0202016-01-26 23:30:18 +01003551
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003552 fd = channel->ch_part[part].ch_fd;
3553 if (fd == INVALID_FD)
3554 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003555 ch_error(channel, "channel_read() called while %s part is closed",
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003556 part_names[part]);
Bram Moolenaard04a0202016-01-26 23:30:18 +01003557 return;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003558 }
3559 use_socket = fd == channel->CH_SOCK_FD;
Bram Moolenaard04a0202016-01-26 23:30:18 +01003560
Bram Moolenaarc667da52019-11-30 20:52:27 +01003561 // Allocate a buffer to read into.
Bram Moolenaard04a0202016-01-26 23:30:18 +01003562 if (buf == NULL)
3563 {
3564 buf = alloc(MAXMSGSIZE);
3565 if (buf == NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01003566 return; // out of memory!
Bram Moolenaard04a0202016-01-26 23:30:18 +01003567 }
3568
Bram Moolenaarc667da52019-11-30 20:52:27 +01003569 // Keep on reading for as long as there is something to read.
3570 // Use select() or poll() to avoid blocking on a message that is exactly
3571 // MAXMSGSIZE long.
Bram Moolenaard04a0202016-01-26 23:30:18 +01003572 for (;;)
3573 {
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003574 if (channel_wait(channel, fd, 0) != CW_READY)
Bram Moolenaard04a0202016-01-26 23:30:18 +01003575 break;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01003576 if (use_socket)
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +01003577 len = sock_read(fd, (char *)buf, MAXMSGSIZE);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01003578 else
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +01003579 len = fd_read(fd, (char *)buf, MAXMSGSIZE);
Bram Moolenaard04a0202016-01-26 23:30:18 +01003580 if (len <= 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +01003581 break; // error or nothing more to read
Bram Moolenaard04a0202016-01-26 23:30:18 +01003582
Bram Moolenaarc667da52019-11-30 20:52:27 +01003583 // Store the read message in the queue.
Bram Moolenaar46c00a62016-03-28 14:11:42 +02003584 channel_save(channel, part, buf, len, FALSE, "RECV ");
Bram Moolenaard04a0202016-01-26 23:30:18 +01003585 readlen += len;
3586 if (len < MAXMSGSIZE)
Bram Moolenaarc667da52019-11-30 20:52:27 +01003587 break; // did read everything that's available
Bram Moolenaard04a0202016-01-26 23:30:18 +01003588 }
3589
Bram Moolenaarc667da52019-11-30 20:52:27 +01003590 // Reading a disconnection (readlen == 0), or an error.
Bram Moolenaarbd73ae12016-02-22 22:19:22 +01003591 if (readlen <= 0)
Bram Moolenaar13ebb032017-08-26 22:02:51 +02003592 {
3593 if (!channel->ch_keep_open)
3594 ch_close_part_on_error(channel, part, (len < 0), func);
3595 }
Bram Moolenaard04a0202016-01-26 23:30:18 +01003596#if defined(CH_HAS_GUI) && defined(FEAT_GUI_GTK)
Bram Moolenaar13ebb032017-08-26 22:02:51 +02003597 else if (CH_HAS_GUI && gtk_main_level() > 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +01003598 // signal the main loop that there is something to read
Bram Moolenaard04a0202016-01-26 23:30:18 +01003599 gtk_main_quit();
3600#endif
3601}
3602
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003603/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003604 * Read from RAW or NL "channel"/"part". Blocks until there is something to
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003605 * read or the timeout expires.
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003606 * When "raw" is TRUE don't block waiting on a NL.
Bram Moolenaar0e57dd82019-09-16 22:56:03 +02003607 * Does not trigger timers or handle messages.
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003608 * Returns what was read in allocated memory.
3609 * Returns NULL in case of error or timeout.
3610 */
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003611 static char_u *
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003612channel_read_block(
3613 channel_T *channel, ch_part_T part, int timeout, int raw, int *outlen)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003614{
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003615 char_u *buf;
3616 char_u *msg;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003617 ch_mode_T mode = channel->ch_part[part].ch_mode;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003618 sock_T fd = channel->ch_part[part].ch_fd;
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003619 char_u *nl;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003620 readq_T *node;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01003621
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003622 ch_log(channel, "Blocking %s read, timeout: %d msec",
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003623 mode == MODE_RAW ? "RAW" : "NL", timeout);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003624
3625 while (TRUE)
3626 {
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003627 node = channel_peek(channel, part);
3628 if (node != NULL)
3629 {
3630 if (mode == MODE_RAW || (mode == MODE_NL
3631 && channel_first_nl(node) != NULL))
Bram Moolenaarc667da52019-11-30 20:52:27 +01003632 // got a complete message
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003633 break;
3634 if (channel_collapse(channel, part, mode == MODE_NL) == OK)
3635 continue;
Bram Moolenaarc667da52019-11-30 20:52:27 +01003636 // If not blocking or nothing more is coming then return what we
3637 // have.
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003638 if (raw || fd == INVALID_FD)
3639 break;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003640 }
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003641
Bram Moolenaarc667da52019-11-30 20:52:27 +01003642 // Wait for up to the channel timeout.
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003643 if (fd == INVALID_FD)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003644 return NULL;
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003645 if (channel_wait(channel, fd, timeout) != CW_READY)
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003646 {
3647 ch_log(channel, "Timed out");
3648 return NULL;
3649 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003650 channel_read(channel, part, "channel_read_block");
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003651 }
3652
Bram Moolenaarc667da52019-11-30 20:52:27 +01003653 // We have a complete message now.
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003654 if (mode == MODE_RAW || outlen != NULL)
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003655 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003656 msg = channel_get_all(channel, part, outlen);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003657 }
3658 else
3659 {
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003660 char_u *p;
3661
3662 buf = node->rq_buffer;
3663 nl = channel_first_nl(node);
3664
Bram Moolenaarc667da52019-11-30 20:52:27 +01003665 // Convert NUL to NL, the internal representation.
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003666 for (p = buf; (nl == NULL || p < nl) && p < buf + node->rq_buflen; ++p)
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003667 if (*p == NUL)
3668 *p = NL;
3669
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003670 if (nl == NULL)
3671 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01003672 // must be a closed channel with missing NL
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003673 msg = channel_get(channel, part, NULL);
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003674 }
3675 else if (nl + 1 == buf + node->rq_buflen)
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003676 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01003677 // get the whole buffer
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003678 msg = channel_get(channel, part, NULL);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003679 *nl = NUL;
3680 }
3681 else
3682 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01003683 // Copy the message into allocated memory and remove it from the
3684 // buffer.
Bram Moolenaardf44a272020-06-07 20:49:05 +02003685 msg = vim_strnsave(buf, nl - buf);
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003686 channel_consume(channel, part, (int)(nl - buf) + 1);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003687 }
3688 }
Bram Moolenaar71eeb742017-09-13 22:18:01 +02003689 if (ch_log_active())
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003690 ch_log(channel, "Returning %d bytes", (int)STRLEN(msg));
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003691 return msg;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003692}
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003693
Bram Moolenaar0e57dd82019-09-16 22:56:03 +02003694static int channel_blocking_wait = 0;
3695
3696/*
3697 * Return TRUE if in a blocking wait that might trigger callbacks.
3698 */
3699 int
3700channel_in_blocking_wait(void)
3701{
3702 return channel_blocking_wait > 0;
3703}
3704
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003705/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003706 * Read one JSON message with ID "id" from "channel"/"part" and store the
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003707 * result in "rettv".
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01003708 * When "id" is -1 accept any message;
Bram Moolenaar4d919d72016-02-05 22:36:41 +01003709 * Blocks until the message is received or the timeout is reached.
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003710 * In corner cases this can be called recursively, that is why ch_block_ids is
3711 * a list.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003712 */
Bram Moolenaar958dc692016-12-01 15:34:12 +01003713 static int
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01003714channel_read_json_block(
Bram Moolenaard6051b52016-02-28 15:49:03 +01003715 channel_T *channel,
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003716 ch_part_T part,
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003717 int timeout_arg,
Bram Moolenaard6051b52016-02-28 15:49:03 +01003718 int id,
3719 typval_T **rettv)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003720{
Bram Moolenaare56bf152016-02-08 23:23:42 +01003721 int more;
Bram Moolenaard8070362016-02-15 21:56:54 +01003722 sock_T fd;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003723 int timeout;
3724 chanpart_T *chanpart = &channel->ch_part[part];
Bram Moolenaar8aeec402019-09-15 23:02:04 +02003725 int retval = FAIL;
Bram Moolenaard7ece102016-02-02 23:23:02 +01003726
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003727 ch_log(channel, "Blocking read JSON for id %d", id);
Bram Moolenaar0e57dd82019-09-16 22:56:03 +02003728 ++channel_blocking_wait;
Bram Moolenaar8aeec402019-09-15 23:02:04 +02003729
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003730 if (id >= 0)
3731 channel_add_block_id(chanpart, id);
Bram Moolenaar8aeec402019-09-15 23:02:04 +02003732
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003733 for (;;)
3734 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003735 more = channel_parse_json(channel, part);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003736
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003737 // search for message "id"
Bram Moolenaar958dc692016-12-01 15:34:12 +01003738 if (channel_get_json(channel, part, id, TRUE, rettv) == OK)
Bram Moolenaare56bf152016-02-08 23:23:42 +01003739 {
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003740 ch_log(channel, "Received JSON for id %d", id);
Bram Moolenaar8aeec402019-09-15 23:02:04 +02003741 retval = OK;
3742 break;
Bram Moolenaare56bf152016-02-08 23:23:42 +01003743 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003744
Bram Moolenaard7ece102016-02-02 23:23:02 +01003745 if (!more)
3746 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01003747 // Handle any other messages in the queue. If done some more
3748 // messages may have arrived.
Bram Moolenaard7ece102016-02-02 23:23:02 +01003749 if (channel_parse_messages())
3750 continue;
3751
Bram Moolenaarc667da52019-11-30 20:52:27 +01003752 // Wait for up to the timeout. If there was an incomplete message
3753 // use the deadline for that.
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003754 timeout = timeout_arg;
Bram Moolenaar88989cc2017-02-06 21:56:09 +01003755 if (chanpart->ch_wait_len > 0)
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003756 {
Bram Moolenaar4f974752019-02-17 17:44:42 +01003757#ifdef MSWIN
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003758 timeout = chanpart->ch_deadline - GetTickCount() + 1;
3759#else
3760 {
3761 struct timeval now_tv;
3762
3763 gettimeofday(&now_tv, NULL);
3764 timeout = (chanpart->ch_deadline.tv_sec
3765 - now_tv.tv_sec) * 1000
3766 + (chanpart->ch_deadline.tv_usec
3767 - now_tv.tv_usec) / 1000
3768 + 1;
3769 }
3770#endif
3771 if (timeout < 0)
3772 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01003773 // Something went wrong, channel_parse_json() didn't
3774 // discard message. Cancel waiting.
Bram Moolenaar88989cc2017-02-06 21:56:09 +01003775 chanpart->ch_wait_len = 0;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003776 timeout = timeout_arg;
3777 }
3778 else if (timeout > timeout_arg)
3779 timeout = timeout_arg;
3780 }
3781 fd = chanpart->ch_fd;
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003782 if (fd == INVALID_FD
3783 || channel_wait(channel, fd, timeout) != CW_READY)
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003784 {
3785 if (timeout == timeout_arg)
3786 {
3787 if (fd != INVALID_FD)
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003788 ch_log(channel, "Timed out on id %d", id);
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003789 break;
3790 }
3791 }
3792 else
3793 channel_read(channel, part, "channel_read_json_block");
Bram Moolenaard7ece102016-02-02 23:23:02 +01003794 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003795 }
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003796 if (id >= 0)
3797 channel_remove_block_id(chanpart, id);
Bram Moolenaar0e57dd82019-09-16 22:56:03 +02003798 --channel_blocking_wait;
Bram Moolenaar8aeec402019-09-15 23:02:04 +02003799
Bram Moolenaar8aeec402019-09-15 23:02:04 +02003800 return retval;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003801}
3802
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003803/*
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02003804 * Get the channel from the argument.
3805 * Returns NULL if the handle is invalid.
3806 * When "check_open" is TRUE check that the channel can be used.
3807 * When "reading" is TRUE "check_open" considers typeahead useful.
3808 * "part" is used to check typeahead, when PART_COUNT use the default part.
3809 */
3810 static channel_T *
3811get_channel_arg(typval_T *tv, int check_open, int reading, ch_part_T part)
3812{
3813 channel_T *channel = NULL;
3814 int has_readahead = FALSE;
3815
3816 if (tv->v_type == VAR_JOB)
3817 {
3818 if (tv->vval.v_job != NULL)
3819 channel = tv->vval.v_job->jv_channel;
3820 }
3821 else if (tv->v_type == VAR_CHANNEL)
3822 {
3823 channel = tv->vval.v_channel;
3824 }
3825 else
3826 {
3827 semsg(_(e_invarg2), tv_get_string(tv));
3828 return NULL;
3829 }
3830 if (channel != NULL && reading)
3831 has_readahead = channel_has_readahead(channel,
3832 part != PART_COUNT ? part : channel_part_read(channel));
3833
3834 if (check_open && (channel == NULL || (!channel_is_open(channel)
3835 && !(reading && has_readahead))))
3836 {
3837 emsg(_("E906: not an open channel"));
3838 return NULL;
3839 }
3840 return channel;
3841}
3842
3843/*
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003844 * Common for ch_read() and ch_readraw().
3845 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02003846 static void
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003847common_channel_read(typval_T *argvars, typval_T *rettv, int raw, int blob)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003848{
3849 channel_T *channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003850 ch_part_T part = PART_COUNT;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003851 jobopt_T opt;
3852 int mode;
3853 int timeout;
3854 int id = -1;
3855 typval_T *listtv = NULL;
3856
Bram Moolenaarc667da52019-11-30 20:52:27 +01003857 // return an empty string by default
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003858 rettv->v_type = VAR_STRING;
3859 rettv->vval.v_string = NULL;
3860
3861 clear_job_options(&opt);
Bram Moolenaar08d384f2017-08-11 21:51:23 +02003862 if (get_job_options(&argvars[1], &opt, JO_TIMEOUT + JO_PART + JO_ID, 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003863 == FAIL)
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02003864 goto theend;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003865
Bram Moolenaar437905c2016-04-26 19:01:05 +02003866 if (opt.jo_set & JO_PART)
3867 part = opt.jo_part;
3868 channel = get_channel_arg(&argvars[0], TRUE, TRUE, part);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003869 if (channel != NULL)
3870 {
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003871 if (part == PART_COUNT)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003872 part = channel_part_read(channel);
3873 mode = channel_get_mode(channel, part);
3874 timeout = channel_get_timeout(channel, part);
3875 if (opt.jo_set & JO_TIMEOUT)
3876 timeout = opt.jo_timeout;
3877
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003878 if (blob)
3879 {
3880 int outlen = 0;
3881 char_u *p = channel_read_block(channel, part,
3882 timeout, TRUE, &outlen);
3883 if (p != NULL)
3884 {
3885 blob_T *b = blob_alloc();
3886
3887 if (b != NULL)
3888 {
3889 b->bv_ga.ga_len = outlen;
3890 if (ga_grow(&b->bv_ga, outlen) == FAIL)
3891 blob_free(b);
3892 else
3893 {
3894 memcpy(b->bv_ga.ga_data, p, outlen);
3895 rettv_blob_set(rettv, b);
3896 }
3897 }
3898 vim_free(p);
3899 }
3900 }
3901 else if (raw || mode == MODE_RAW || mode == MODE_NL)
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003902 rettv->vval.v_string = channel_read_block(channel, part,
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003903 timeout, raw, NULL);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003904 else
3905 {
3906 if (opt.jo_set & JO_ID)
3907 id = opt.jo_id;
3908 channel_read_json_block(channel, part, timeout, id, &listtv);
3909 if (listtv != NULL)
3910 {
3911 *rettv = *listtv;
3912 vim_free(listtv);
3913 }
3914 else
3915 {
3916 rettv->v_type = VAR_SPECIAL;
3917 rettv->vval.v_number = VVAL_NONE;
3918 }
3919 }
3920 }
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02003921
3922theend:
3923 free_job_options(&opt);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003924}
3925
Bram Moolenaar80a8d382020-05-03 22:57:32 +02003926#if defined(MSWIN) || defined(__HAIKU__) || defined(FEAT_GUI) || defined(PROTO)
Bram Moolenaarb7522a22016-02-21 17:20:55 +01003927/*
3928 * Check the channels for anything that is ready to be read.
3929 * The data is put in the read queue.
Bram Moolenaar13ebb032017-08-26 22:02:51 +02003930 * if "only_keep_open" is TRUE only check channels where ch_keep_open is set.
Bram Moolenaarb7522a22016-02-21 17:20:55 +01003931 */
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003932 void
Bram Moolenaar13ebb032017-08-26 22:02:51 +02003933channel_handle_events(int only_keep_open)
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003934{
3935 channel_T *channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003936 ch_part_T part;
Bram Moolenaarb7522a22016-02-21 17:20:55 +01003937 sock_T fd;
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003938
Bram Moolenaaraeea7212020-04-02 18:50:46 +02003939 FOR_ALL_CHANNELS(channel)
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003940 {
Bram Moolenaar13ebb032017-08-26 22:02:51 +02003941 if (only_keep_open && !channel->ch_keep_open)
3942 continue;
3943
Bram Moolenaarc667da52019-11-30 20:52:27 +01003944 // check the socket and pipes
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003945 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaarb7522a22016-02-21 17:20:55 +01003946 {
3947 fd = channel->ch_part[part].ch_fd;
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003948 if (fd != INVALID_FD)
3949 {
3950 int r = channel_wait(channel, fd, 0);
3951
3952 if (r == CW_READY)
3953 channel_read(channel, part, "channel_handle_events");
3954 else if (r == CW_ERROR)
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003955 ch_close_part_on_error(channel, part, TRUE,
3956 "channel_handle_events");
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003957 }
Bram Moolenaarb7522a22016-02-21 17:20:55 +01003958 }
Bram Moolenaar80a8d382020-05-03 22:57:32 +02003959
3960# ifdef __HAIKU__
3961 // Workaround for Haiku: Since select/poll cannot detect EOF from tty,
3962 // should close fds when the job has finished if 'channel' connects to
3963 // the pty.
3964 if (channel->ch_job != NULL)
3965 {
3966 job_T *job = channel->ch_job;
3967
3968 if (job->jv_tty_out != NULL && job->jv_status == JOB_FINISHED)
3969 for (part = PART_SOCK; part < PART_COUNT; ++part)
3970 ch_close_part(channel, part);
3971 }
3972# endif
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003973 }
3974}
Bram Moolenaar80a8d382020-05-03 22:57:32 +02003975#endif
Bram Moolenaar85be35f2016-01-27 21:08:18 +01003976
Bram Moolenaar4ab79682017-08-27 14:50:47 +02003977# if defined(FEAT_GUI) || defined(PROTO)
3978/*
3979 * Return TRUE when there is any channel with a keep_open flag.
3980 */
3981 int
3982channel_any_keep_open()
3983{
3984 channel_T *channel;
3985
Bram Moolenaaraeea7212020-04-02 18:50:46 +02003986 FOR_ALL_CHANNELS(channel)
Bram Moolenaar4ab79682017-08-27 14:50:47 +02003987 if (channel->ch_keep_open)
3988 return TRUE;
3989 return FALSE;
3990}
3991# endif
3992
Bram Moolenaard04a0202016-01-26 23:30:18 +01003993/*
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02003994 * Set "channel"/"part" to non-blocking.
Bram Moolenaarf66a2cd2017-08-18 21:53:22 +02003995 * Only works for sockets and pipes.
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02003996 */
3997 void
3998channel_set_nonblock(channel_T *channel, ch_part_T part)
3999{
4000 chanpart_T *ch_part = &channel->ch_part[part];
Bram Moolenaar0b146882018-09-06 16:27:24 +02004001 int fd = ch_part->ch_fd;
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004002
4003 if (fd != INVALID_FD)
4004 {
Bram Moolenaar4f974752019-02-17 17:44:42 +01004005#ifdef MSWIN
Bram Moolenaarf66a2cd2017-08-18 21:53:22 +02004006 u_long val = 1;
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004007
Bram Moolenaarf66a2cd2017-08-18 21:53:22 +02004008 ioctlsocket(fd, FIONBIO, &val);
4009#else
Bram Moolenaardc926dd2017-08-19 21:26:44 +02004010 (void)fcntl(fd, F_SETFL, O_NONBLOCK);
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004011#endif
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004012 ch_part->ch_nonblocking = TRUE;
4013 }
4014}
4015
4016/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004017 * Write "buf" (NUL terminated string) to "channel"/"part".
Bram Moolenaard04a0202016-01-26 23:30:18 +01004018 * When "fun" is not NULL an error message might be given.
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01004019 * Return FAIL or OK.
Bram Moolenaard04a0202016-01-26 23:30:18 +01004020 */
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01004021 int
Bram Moolenaar79cbdcb2016-11-11 21:14:03 +01004022channel_send(
4023 channel_T *channel,
4024 ch_part_T part,
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004025 char_u *buf_arg,
4026 int len_arg,
Bram Moolenaar79cbdcb2016-11-11 21:14:03 +01004027 char *fun)
Bram Moolenaard04a0202016-01-26 23:30:18 +01004028{
Bram Moolenaar6463ca22016-02-13 17:04:46 +01004029 int res;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004030 sock_T fd;
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004031 chanpart_T *ch_part = &channel->ch_part[part];
4032 int did_use_queue = FALSE;
Bram Moolenaard04a0202016-01-26 23:30:18 +01004033
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004034 fd = ch_part->ch_fd;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004035 if (fd == INVALID_FD)
Bram Moolenaard04a0202016-01-26 23:30:18 +01004036 {
4037 if (!channel->ch_error && fun != NULL)
4038 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02004039 ch_error(channel, "%s(): write while not connected", fun);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004040 semsg(_("E630: %s(): write while not connected"), fun);
Bram Moolenaard04a0202016-01-26 23:30:18 +01004041 }
4042 channel->ch_error = TRUE;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01004043 return FAIL;
Bram Moolenaard04a0202016-01-26 23:30:18 +01004044 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01004045
Bram Moolenaar0b146882018-09-06 16:27:24 +02004046 if (channel->ch_nonblock && !ch_part->ch_nonblocking)
4047 channel_set_nonblock(channel, part);
4048
Bram Moolenaar71eeb742017-09-13 22:18:01 +02004049 if (ch_log_active())
Bram Moolenaar6463ca22016-02-13 17:04:46 +01004050 {
Bram Moolenaar4b16ee72018-08-09 22:15:34 +02004051 ch_log_lead("SEND ", channel, part);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01004052 fprintf(log_fd, "'");
Bram Moolenaar42335f52018-09-13 15:33:43 +02004053 vim_ignored = (int)fwrite(buf_arg, len_arg, 1, log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01004054 fprintf(log_fd, "'\n");
4055 fflush(log_fd);
Bram Moolenaar101e9922019-09-25 21:43:11 +02004056 did_repeated_msg = 0;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01004057 }
4058
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004059 for (;;)
Bram Moolenaard04a0202016-01-26 23:30:18 +01004060 {
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004061 writeq_T *wq = &ch_part->ch_writeque;
4062 char_u *buf;
4063 int len;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01004064
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004065 if (wq->wq_next != NULL)
4066 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004067 // first write what was queued
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004068 buf = wq->wq_next->wq_ga.ga_data;
4069 len = wq->wq_next->wq_ga.ga_len;
4070 did_use_queue = TRUE;
4071 }
4072 else
4073 {
4074 if (len_arg == 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +01004075 // nothing to write, called from channel_select_check()
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004076 return OK;
4077 buf = buf_arg;
4078 len = len_arg;
4079 }
4080
4081 if (part == PART_SOCK)
4082 res = sock_write(fd, (char *)buf, len);
4083 else
Bram Moolenaar31faed62019-01-22 23:01:40 +01004084 {
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004085 res = fd_write(fd, (char *)buf, len);
Bram Moolenaar4f974752019-02-17 17:44:42 +01004086#ifdef MSWIN
Bram Moolenaar31faed62019-01-22 23:01:40 +01004087 if (channel->ch_named_pipe && res < 0)
4088 {
4089 DisconnectNamedPipe((HANDLE)fd);
4090 ConnectNamedPipe((HANDLE)fd, NULL);
4091 }
4092#endif
4093 }
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004094 if (res < 0 && (errno == EWOULDBLOCK
4095#ifdef EAGAIN
4096 || errno == EAGAIN
4097#endif
4098 ))
Bram Moolenaarc667da52019-11-30 20:52:27 +01004099 res = 0; // nothing got written
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004100
4101 if (res >= 0 && ch_part->ch_nonblocking)
4102 {
4103 writeq_T *entry = wq->wq_next;
4104
4105 if (did_use_queue)
4106 ch_log(channel, "Sent %d bytes now", res);
4107 if (res == len)
4108 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004109 // Wrote all the buf[len] bytes.
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004110 if (entry != NULL)
4111 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004112 // Remove the entry from the write queue.
Bram Moolenaaraba680a2017-09-09 16:42:53 +02004113 remove_from_writeque(wq, entry);
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004114 continue;
4115 }
4116 if (did_use_queue)
4117 ch_log(channel, "Write queue empty");
4118 }
4119 else
4120 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004121 // Wrote only buf[res] bytes, can't write more now.
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004122 if (entry != NULL)
4123 {
4124 if (res > 0)
4125 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004126 // Remove the bytes that were written.
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004127 mch_memmove(entry->wq_ga.ga_data,
4128 (char *)entry->wq_ga.ga_data + res,
4129 len - res);
4130 entry->wq_ga.ga_len -= res;
4131 }
4132 buf = buf_arg;
4133 len = len_arg;
4134 }
4135 else
4136 {
4137 buf += res;
4138 len -= res;
4139 }
4140 ch_log(channel, "Adding %d bytes to the write queue", len);
4141
Bram Moolenaarc667da52019-11-30 20:52:27 +01004142 // Append the not written bytes of the argument to the write
4143 // buffer. Limit entries to 4000 bytes.
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004144 if (wq->wq_prev != NULL
4145 && wq->wq_prev->wq_ga.ga_len + len < 4000)
4146 {
4147 writeq_T *last = wq->wq_prev;
4148
Bram Moolenaarc667da52019-11-30 20:52:27 +01004149 // append to the last entry
Bram Moolenaar0d071552019-07-08 22:04:03 +02004150 if (len > 0 && ga_grow(&last->wq_ga, len) == OK)
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004151 {
4152 mch_memmove((char *)last->wq_ga.ga_data
4153 + last->wq_ga.ga_len,
4154 buf, len);
4155 last->wq_ga.ga_len += len;
4156 }
4157 }
4158 else
4159 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02004160 writeq_T *last = ALLOC_ONE(writeq_T);
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004161
4162 if (last != NULL)
4163 {
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004164 last->wq_prev = wq->wq_prev;
4165 last->wq_next = NULL;
4166 if (wq->wq_prev == NULL)
4167 wq->wq_next = last;
4168 else
4169 wq->wq_prev->wq_next = last;
4170 wq->wq_prev = last;
4171 ga_init2(&last->wq_ga, 1, 1000);
Bram Moolenaar0d071552019-07-08 22:04:03 +02004172 if (len > 0 && ga_grow(&last->wq_ga, len) == OK)
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004173 {
4174 mch_memmove(last->wq_ga.ga_data, buf, len);
4175 last->wq_ga.ga_len = len;
4176 }
4177 }
4178 }
4179 }
4180 }
4181 else if (res != len)
4182 {
4183 if (!channel->ch_error && fun != NULL)
4184 {
4185 ch_error(channel, "%s(): write failed", fun);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004186 semsg(_("E631: %s(): write failed"), fun);
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004187 }
4188 channel->ch_error = TRUE;
4189 return FAIL;
4190 }
4191
4192 channel->ch_error = FALSE;
4193 return OK;
4194 }
Bram Moolenaard04a0202016-01-26 23:30:18 +01004195}
4196
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004197/*
4198 * Common for "ch_sendexpr()" and "ch_sendraw()".
4199 * Returns the channel if the caller should read the response.
Bram Moolenaaraad30bb2016-06-26 17:31:03 +02004200 * Sets "part_read" to the read fd.
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004201 * Otherwise returns NULL.
4202 */
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004203 static channel_T *
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004204send_common(
4205 typval_T *argvars,
4206 char_u *text,
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004207 int len,
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004208 int id,
4209 int eval,
4210 jobopt_T *opt,
4211 char *fun,
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004212 ch_part_T *part_read)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004213{
4214 channel_T *channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004215 ch_part_T part_send;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004216
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02004217 clear_job_options(opt);
Bram Moolenaar437905c2016-04-26 19:01:05 +02004218 channel = get_channel_arg(&argvars[0], TRUE, FALSE, 0);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004219 if (channel == NULL)
4220 return NULL;
4221 part_send = channel_part_send(channel);
4222 *part_read = channel_part_read(channel);
4223
Bram Moolenaar08d384f2017-08-11 21:51:23 +02004224 if (get_job_options(&argvars[2], opt, JO_CALLBACK + JO_TIMEOUT, 0) == FAIL)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004225 return NULL;
4226
Bram Moolenaarc667da52019-11-30 20:52:27 +01004227 // Set the callback. An empty callback means no callback and not reading
4228 // the response. With "ch_evalexpr()" and "ch_evalraw()" a callback is not
4229 // allowed.
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004230 if (opt->jo_callback.cb_name != NULL && *opt->jo_callback.cb_name != NUL)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004231 {
4232 if (eval)
4233 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004234 semsg(_("E917: Cannot use a callback with %s()"), fun);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004235 return NULL;
4236 }
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004237 channel_set_req_callback(channel, *part_read, &opt->jo_callback, id);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004238 }
4239
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004240 if (channel_send(channel, part_send, text, len, fun) == OK
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004241 && opt->jo_callback.cb_name == NULL)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004242 return channel;
4243 return NULL;
4244}
4245
4246/*
4247 * common for "ch_evalexpr()" and "ch_sendexpr()"
4248 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02004249 static void
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004250ch_expr_common(typval_T *argvars, typval_T *rettv, int eval)
4251{
4252 char_u *text;
4253 typval_T *listtv;
4254 channel_T *channel;
4255 int id;
4256 ch_mode_T ch_mode;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004257 ch_part_T part_send;
4258 ch_part_T part_read;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004259 jobopt_T opt;
4260 int timeout;
4261
Bram Moolenaarc667da52019-11-30 20:52:27 +01004262 // return an empty string by default
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004263 rettv->v_type = VAR_STRING;
4264 rettv->vval.v_string = NULL;
4265
Bram Moolenaar437905c2016-04-26 19:01:05 +02004266 channel = get_channel_arg(&argvars[0], TRUE, FALSE, 0);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004267 if (channel == NULL)
4268 return;
4269 part_send = channel_part_send(channel);
4270
4271 ch_mode = channel_get_mode(channel, part_send);
4272 if (ch_mode == MODE_RAW || ch_mode == MODE_NL)
4273 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004274 emsg(_("E912: cannot use ch_evalexpr()/ch_sendexpr() with a raw or nl channel"));
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004275 return;
4276 }
4277
Bram Moolenaare9d6a292016-03-20 19:31:33 +01004278 id = ++channel->ch_last_msg_id;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004279 text = json_encode_nr_expr(id, &argvars[1],
Bram Moolenaarf1f07922016-08-26 17:58:53 +02004280 (ch_mode == MODE_JS ? JSON_JS : 0) | JSON_NL);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004281 if (text == NULL)
4282 return;
4283
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004284 channel = send_common(argvars, text, (int)STRLEN(text), id, eval, &opt,
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004285 eval ? "ch_evalexpr" : "ch_sendexpr", &part_read);
4286 vim_free(text);
4287 if (channel != NULL && eval)
4288 {
4289 if (opt.jo_set & JO_TIMEOUT)
4290 timeout = opt.jo_timeout;
4291 else
4292 timeout = channel_get_timeout(channel, part_read);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004293 if (channel_read_json_block(channel, part_read, timeout, id, &listtv)
4294 == OK)
4295 {
4296 list_T *list = listtv->vval.v_list;
4297
Bram Moolenaarc667da52019-11-30 20:52:27 +01004298 // Move the item from the list and then change the type to
4299 // avoid the value being freed.
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01004300 *rettv = list->lv_u.mat.lv_last->li_tv;
4301 list->lv_u.mat.lv_last->li_tv.v_type = VAR_NUMBER;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004302 free_tv(listtv);
4303 }
4304 }
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02004305 free_job_options(&opt);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004306}
4307
4308/*
4309 * common for "ch_evalraw()" and "ch_sendraw()"
4310 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02004311 static void
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004312ch_raw_common(typval_T *argvars, typval_T *rettv, int eval)
4313{
4314 char_u buf[NUMBUFLEN];
4315 char_u *text;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004316 int len;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004317 channel_T *channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004318 ch_part_T part_read;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004319 jobopt_T opt;
4320 int timeout;
4321
Bram Moolenaarc667da52019-11-30 20:52:27 +01004322 // return an empty string by default
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004323 rettv->v_type = VAR_STRING;
4324 rettv->vval.v_string = NULL;
4325
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004326 if (argvars[1].v_type == VAR_BLOB)
4327 {
4328 text = argvars[1].vval.v_blob->bv_ga.ga_data;
4329 len = argvars[1].vval.v_blob->bv_ga.ga_len;
4330 }
4331 else
4332 {
4333 text = tv_get_string_buf(&argvars[1], buf);
Bram Moolenaare4074252019-01-17 14:31:14 +01004334 len = (int)STRLEN(text);
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004335 }
4336 channel = send_common(argvars, text, len, 0, eval, &opt,
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004337 eval ? "ch_evalraw" : "ch_sendraw", &part_read);
4338 if (channel != NULL && eval)
4339 {
4340 if (opt.jo_set & JO_TIMEOUT)
4341 timeout = opt.jo_timeout;
4342 else
4343 timeout = channel_get_timeout(channel, part_read);
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01004344 rettv->vval.v_string = channel_read_block(channel, part_read,
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004345 timeout, TRUE, NULL);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004346 }
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02004347 free_job_options(&opt);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004348}
4349
Bram Moolenaarc667da52019-11-30 20:52:27 +01004350#define KEEP_OPEN_TIME 20 // msec
Bram Moolenaarf3360612017-10-01 16:21:31 +02004351
Bram Moolenaar8aeec402019-09-15 23:02:04 +02004352#if (defined(UNIX) && !defined(HAVE_SELECT)) || defined(PROTO)
Bram Moolenaare0874f82016-01-24 20:36:41 +01004353/*
4354 * Add open channels to the poll struct.
4355 * Return the adjusted struct index.
4356 * The type of "fds" is hidden to avoid problems with the function proto.
4357 */
4358 int
Bram Moolenaarf3360612017-10-01 16:21:31 +02004359channel_poll_setup(int nfd_in, void *fds_in, int *towait)
Bram Moolenaare0874f82016-01-24 20:36:41 +01004360{
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004361 int nfd = nfd_in;
4362 channel_T *channel;
4363 struct pollfd *fds = fds_in;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004364 ch_part_T part;
Bram Moolenaare0874f82016-01-24 20:36:41 +01004365
Bram Moolenaaraeea7212020-04-02 18:50:46 +02004366 FOR_ALL_CHANNELS(channel)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004367 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004368 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004369 {
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004370 chanpart_T *ch_part = &channel->ch_part[part];
4371
4372 if (ch_part->ch_fd != INVALID_FD)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004373 {
Bram Moolenaarf3360612017-10-01 16:21:31 +02004374 if (channel->ch_keep_open)
4375 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004376 // For unknown reason poll() returns immediately for a
4377 // keep-open channel. Instead of adding it to the fds add
4378 // a short timeout and check, like polling.
Bram Moolenaarf3360612017-10-01 16:21:31 +02004379 if (*towait < 0 || *towait > KEEP_OPEN_TIME)
4380 *towait = KEEP_OPEN_TIME;
4381 }
4382 else
4383 {
4384 ch_part->ch_poll_idx = nfd;
4385 fds[nfd].fd = ch_part->ch_fd;
4386 fds[nfd].events = POLLIN;
4387 nfd++;
4388 }
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004389 }
4390 else
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004391 channel->ch_part[part].ch_poll_idx = -1;
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004392 }
4393 }
Bram Moolenaare0874f82016-01-24 20:36:41 +01004394
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004395 nfd = channel_fill_poll_write(nfd, fds);
4396
Bram Moolenaare0874f82016-01-24 20:36:41 +01004397 return nfd;
4398}
4399
4400/*
4401 * The type of "fds" is hidden to avoid problems with the function proto.
4402 */
4403 int
4404channel_poll_check(int ret_in, void *fds_in)
4405{
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004406 int ret = ret_in;
4407 channel_T *channel;
4408 struct pollfd *fds = fds_in;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004409 ch_part_T part;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004410 int idx;
4411 chanpart_T *in_part;
Bram Moolenaare0874f82016-01-24 20:36:41 +01004412
Bram Moolenaaraeea7212020-04-02 18:50:46 +02004413 FOR_ALL_CHANNELS(channel)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004414 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004415 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004416 {
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004417 idx = channel->ch_part[part].ch_poll_idx;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004418
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004419 if (ret > 0 && idx != -1 && (fds[idx].revents & POLLIN))
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004420 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004421 channel_read(channel, part, "channel_poll_check");
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004422 --ret;
4423 }
Bram Moolenaarf3360612017-10-01 16:21:31 +02004424 else if (channel->ch_part[part].ch_fd != INVALID_FD
4425 && channel->ch_keep_open)
4426 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004427 // polling a keep-open channel
Bram Moolenaarf3360612017-10-01 16:21:31 +02004428 channel_read(channel, part, "channel_poll_check_keep_open");
4429 }
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004430 }
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004431
4432 in_part = &channel->ch_part[PART_IN];
4433 idx = in_part->ch_poll_idx;
4434 if (ret > 0 && idx != -1 && (fds[idx].revents & POLLOUT))
4435 {
Bram Moolenaar683b7962017-08-19 15:51:59 +02004436 channel_write_input(channel);
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004437 --ret;
4438 }
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004439 }
Bram Moolenaare0874f82016-01-24 20:36:41 +01004440
4441 return ret;
4442}
Bram Moolenaarc667da52019-11-30 20:52:27 +01004443#endif // UNIX && !HAVE_SELECT
Bram Moolenaare0874f82016-01-24 20:36:41 +01004444
Bram Moolenaar8aeec402019-09-15 23:02:04 +02004445#if (!defined(MSWIN) && defined(HAVE_SELECT)) || defined(PROTO)
Bram Moolenaarf3360612017-10-01 16:21:31 +02004446
Bram Moolenaare0874f82016-01-24 20:36:41 +01004447/*
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004448 * The "fd_set" type is hidden to avoid problems with the function proto.
Bram Moolenaare0874f82016-01-24 20:36:41 +01004449 */
4450 int
Bram Moolenaarf3360612017-10-01 16:21:31 +02004451channel_select_setup(
4452 int maxfd_in,
4453 void *rfds_in,
4454 void *wfds_in,
4455 struct timeval *tv,
4456 struct timeval **tvp)
Bram Moolenaare0874f82016-01-24 20:36:41 +01004457{
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004458 int maxfd = maxfd_in;
4459 channel_T *channel;
4460 fd_set *rfds = rfds_in;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004461 fd_set *wfds = wfds_in;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004462 ch_part_T part;
Bram Moolenaare0874f82016-01-24 20:36:41 +01004463
Bram Moolenaaraeea7212020-04-02 18:50:46 +02004464 FOR_ALL_CHANNELS(channel)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004465 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004466 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004467 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004468 sock_T fd = channel->ch_part[part].ch_fd;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004469
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004470 if (fd != INVALID_FD)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004471 {
Bram Moolenaarf3360612017-10-01 16:21:31 +02004472 if (channel->ch_keep_open)
4473 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004474 // For unknown reason select() returns immediately for a
4475 // keep-open channel. Instead of adding it to the rfds add
4476 // a short timeout and check, like polling.
Bram Moolenaarf3360612017-10-01 16:21:31 +02004477 if (*tvp == NULL || tv->tv_sec > 0
4478 || tv->tv_usec > KEEP_OPEN_TIME * 1000)
4479 {
4480 *tvp = tv;
4481 tv->tv_sec = 0;
4482 tv->tv_usec = KEEP_OPEN_TIME * 1000;
4483 }
4484 }
4485 else
4486 {
4487 FD_SET((int)fd, rfds);
4488 if (maxfd < (int)fd)
4489 maxfd = (int)fd;
4490 }
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004491 }
4492 }
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004493 }
Bram Moolenaare0874f82016-01-24 20:36:41 +01004494
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004495 maxfd = channel_fill_wfds(maxfd, wfds);
4496
Bram Moolenaare0874f82016-01-24 20:36:41 +01004497 return maxfd;
4498}
4499
4500/*
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004501 * The "fd_set" type is hidden to avoid problems with the function proto.
Bram Moolenaare0874f82016-01-24 20:36:41 +01004502 */
4503 int
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004504channel_select_check(int ret_in, void *rfds_in, void *wfds_in)
Bram Moolenaare0874f82016-01-24 20:36:41 +01004505{
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004506 int ret = ret_in;
4507 channel_T *channel;
4508 fd_set *rfds = rfds_in;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004509 fd_set *wfds = wfds_in;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004510 ch_part_T part;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004511 chanpart_T *in_part;
Bram Moolenaare0874f82016-01-24 20:36:41 +01004512
Bram Moolenaaraeea7212020-04-02 18:50:46 +02004513 FOR_ALL_CHANNELS(channel)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004514 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004515 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004516 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004517 sock_T fd = channel->ch_part[part].ch_fd;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004518
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004519 if (ret > 0 && fd != INVALID_FD && FD_ISSET(fd, rfds))
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004520 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004521 channel_read(channel, part, "channel_select_check");
Bram Moolenaar3c518402017-09-08 20:47:00 +02004522 FD_CLR(fd, rfds);
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004523 --ret;
4524 }
Bram Moolenaarf3360612017-10-01 16:21:31 +02004525 else if (fd != INVALID_FD && channel->ch_keep_open)
4526 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004527 // polling a keep-open channel
Bram Moolenaarf3360612017-10-01 16:21:31 +02004528 channel_read(channel, part, "channel_select_check_keep_open");
4529 }
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004530 }
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004531
4532 in_part = &channel->ch_part[PART_IN];
4533 if (ret > 0 && in_part->ch_fd != INVALID_FD
4534 && FD_ISSET(in_part->ch_fd, wfds))
4535 {
Bram Moolenaar8aeec402019-09-15 23:02:04 +02004536 // Clear the flag first, ch_fd may change in channel_write_input().
Bram Moolenaar3c518402017-09-08 20:47:00 +02004537 FD_CLR(in_part->ch_fd, wfds);
Bram Moolenaar9af97782018-04-03 12:51:01 +02004538 channel_write_input(channel);
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004539 --ret;
4540 }
Bram Moolenaar80a8d382020-05-03 22:57:32 +02004541
4542# ifdef __HAIKU__
4543 // Workaround for Haiku: Since select/poll cannot detect EOF from tty,
4544 // should close fds when the job has finished if 'channel' connects to
4545 // the pty.
4546 if (channel->ch_job != NULL)
4547 {
4548 job_T *job = channel->ch_job;
4549
4550 if (job->jv_tty_out != NULL && job->jv_status == JOB_FINISHED)
4551 for (part = PART_SOCK; part < PART_COUNT; ++part)
4552 ch_close_part(channel, part);
4553 }
4554# endif
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004555 }
Bram Moolenaare0874f82016-01-24 20:36:41 +01004556
4557 return ret;
4558}
Bram Moolenaar8aeec402019-09-15 23:02:04 +02004559#endif // !MSWIN && HAVE_SELECT
Bram Moolenaare0874f82016-01-24 20:36:41 +01004560
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01004561/*
Bram Moolenaard7ece102016-02-02 23:23:02 +01004562 * Execute queued up commands.
Bram Moolenaar8aeec402019-09-15 23:02:04 +02004563 * Invoked from the main loop when it's safe to execute received commands,
4564 * and during a blocking wait for ch_evalexpr().
Bram Moolenaard7ece102016-02-02 23:23:02 +01004565 * Return TRUE when something was done.
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01004566 */
Bram Moolenaard7ece102016-02-02 23:23:02 +01004567 int
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01004568channel_parse_messages(void)
4569{
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01004570 channel_T *channel = first_channel;
4571 int ret = FALSE;
4572 int r;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004573 ch_part_T part = PART_SOCK;
Bram Moolenaar09c56902020-03-28 18:06:31 +01004574 static int recursive = 0;
Bram Moolenaar833eb1d2016-11-24 17:22:50 +01004575#ifdef ELAPSED_FUNC
Bram Moolenaar1ac56c22019-01-17 22:28:22 +01004576 elapsed_T start_tv;
Bram Moolenaar833eb1d2016-11-24 17:22:50 +01004577#endif
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01004578
Bram Moolenaara9c3a302020-03-26 16:03:45 +01004579 // The code below may invoke callbacks, which might call us back.
Bram Moolenaar09c56902020-03-28 18:06:31 +01004580 // In a recursive call channels will not be closed.
4581 ++recursive;
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +02004582 ++safe_to_invoke_callback;
4583
Bram Moolenaara9c3a302020-03-26 16:03:45 +01004584#ifdef ELAPSED_FUNC
4585 ELAPSED_INIT(start_tv);
4586#endif
4587
Bram Moolenaarc667da52019-11-30 20:52:27 +01004588 // Only do this message when another message was given, otherwise we get
4589 // lots of them.
Bram Moolenaar101e9922019-09-25 21:43:11 +02004590 if ((did_repeated_msg & REPEATED_MSG_LOOKING) == 0)
Bram Moolenaard0b65022016-03-06 21:50:33 +01004591 {
4592 ch_log(NULL, "looking for messages on channels");
Bram Moolenaar101e9922019-09-25 21:43:11 +02004593 // now we should also give the message for SafeState
4594 did_repeated_msg = REPEATED_MSG_LOOKING;
Bram Moolenaard0b65022016-03-06 21:50:33 +01004595 }
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01004596 while (channel != NULL)
4597 {
Bram Moolenaar09c56902020-03-28 18:06:31 +01004598 if (recursive == 1)
Bram Moolenaarcf7ff702016-05-09 17:20:14 +02004599 {
Bram Moolenaar09c56902020-03-28 18:06:31 +01004600 if (channel_can_close(channel))
4601 {
4602 channel->ch_to_be_closed = (1U << PART_COUNT);
4603 channel_close_now(channel);
4604 // channel may have been freed, start over
4605 channel = first_channel;
4606 continue;
4607 }
4608 if (channel->ch_to_be_freed || channel->ch_killing)
4609 {
4610 channel_free_contents(channel);
4611 if (channel->ch_job != NULL)
4612 channel->ch_job->jv_channel = NULL;
Bram Moolenaar71658f72020-03-24 20:35:19 +01004613
Bram Moolenaar09c56902020-03-28 18:06:31 +01004614 // free the channel and then start over
4615 channel_free_channel(channel);
4616 channel = first_channel;
4617 continue;
4618 }
4619 if (channel->ch_refcount == 0 && !channel_still_useful(channel))
4620 {
4621 // channel is no longer useful, free it
4622 channel_free(channel);
4623 channel = first_channel;
4624 part = PART_SOCK;
4625 continue;
4626 }
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +02004627 }
Bram Moolenaar09c56902020-03-28 18:06:31 +01004628
Bram Moolenaar187db502016-02-27 14:44:26 +01004629 if (channel->ch_part[part].ch_fd != INVALID_FD
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004630 || channel_has_readahead(channel, part))
Bram Moolenaard7ece102016-02-02 23:23:02 +01004631 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004632 // Increase the refcount, in case the handler causes the channel
4633 // to be unreferenced or closed.
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004634 ++channel->ch_refcount;
4635 r = may_invoke_callback(channel, part);
4636 if (r == OK)
4637 ret = TRUE;
Bram Moolenaar833eb1d2016-11-24 17:22:50 +01004638 if (channel_unref(channel) || (r == OK
4639#ifdef ELAPSED_FUNC
Bram Moolenaarc667da52019-11-30 20:52:27 +01004640 // Limit the time we loop here to 100 msec, otherwise
4641 // Vim becomes unresponsive when the callback takes
4642 // more than a bit of time.
Bram Moolenaar833eb1d2016-11-24 17:22:50 +01004643 && ELAPSED_FUNC(start_tv) < 100L
4644#endif
4645 ))
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004646 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004647 // channel was freed or something was done, start over
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004648 channel = first_channel;
4649 part = PART_SOCK;
4650 continue;
4651 }
Bram Moolenaard7ece102016-02-02 23:23:02 +01004652 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004653 if (part < PART_ERR)
4654 ++part;
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01004655 else
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004656 {
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01004657 channel = channel->ch_next;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004658 part = PART_SOCK;
4659 }
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01004660 }
Bram Moolenaar187db502016-02-27 14:44:26 +01004661
Bram Moolenaar7f7c3322016-04-18 19:27:24 +02004662 if (channel_need_redraw)
Bram Moolenaar187db502016-02-27 14:44:26 +01004663 {
4664 channel_need_redraw = FALSE;
Bram Moolenaar02e177d2017-08-26 23:43:28 +02004665 redraw_after_callback(TRUE);
Bram Moolenaar187db502016-02-27 14:44:26 +01004666 }
4667
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +02004668 --safe_to_invoke_callback;
Bram Moolenaar09c56902020-03-28 18:06:31 +01004669 --recursive;
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +02004670
Bram Moolenaard7ece102016-02-02 23:23:02 +01004671 return ret;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01004672}
4673
Bram Moolenaarfbc4b4d2016-02-07 15:14:01 +01004674/*
Bram Moolenaar8a8199e2016-11-26 15:13:33 +01004675 * Return TRUE if any channel has readahead. That means we should not block on
4676 * waiting for input.
4677 */
4678 int
4679channel_any_readahead(void)
4680{
4681 channel_T *channel = first_channel;
4682 ch_part_T part = PART_SOCK;
4683
4684 while (channel != NULL)
4685 {
4686 if (channel_has_readahead(channel, part))
4687 return TRUE;
4688 if (part < PART_ERR)
4689 ++part;
4690 else
4691 {
4692 channel = channel->ch_next;
4693 part = PART_SOCK;
4694 }
4695 }
4696 return FALSE;
4697}
4698
4699/*
Bram Moolenaarfbc4b4d2016-02-07 15:14:01 +01004700 * Mark references to lists used in channels.
4701 */
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01004702 int
4703set_ref_in_channel(int copyID)
4704{
Bram Moolenaar77073442016-02-13 23:23:53 +01004705 int abort = FALSE;
4706 channel_T *channel;
Bram Moolenaarb8d49052016-05-01 14:22:16 +02004707 typval_T tv;
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01004708
Bram Moolenaar75a1a942019-06-20 03:45:36 +02004709 for (channel = first_channel; !abort && channel != NULL;
4710 channel = channel->ch_next)
Bram Moolenaarb8d49052016-05-01 14:22:16 +02004711 if (channel_still_useful(channel))
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01004712 {
Bram Moolenaarb8d49052016-05-01 14:22:16 +02004713 tv.v_type = VAR_CHANNEL;
4714 tv.vval.v_channel = channel;
4715 abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL);
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01004716 }
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01004717 return abort;
4718}
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01004719
4720/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004721 * Return the "part" to write to for "channel".
4722 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02004723 static ch_part_T
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004724channel_part_send(channel_T *channel)
4725{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004726 if (channel->CH_SOCK_FD == INVALID_FD)
4727 return PART_IN;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004728 return PART_SOCK;
4729}
4730
4731/*
4732 * Return the default "part" to read from for "channel".
4733 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02004734 static ch_part_T
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004735channel_part_read(channel_T *channel)
4736{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004737 if (channel->CH_SOCK_FD == INVALID_FD)
4738 return PART_OUT;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004739 return PART_SOCK;
4740}
4741
4742/*
4743 * Return the mode of "channel"/"part"
Bram Moolenaar77073442016-02-13 23:23:53 +01004744 * If "channel" is invalid returns MODE_JSON.
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01004745 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02004746 static ch_mode_T
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004747channel_get_mode(channel_T *channel, ch_part_T part)
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01004748{
Bram Moolenaar77073442016-02-13 23:23:53 +01004749 if (channel == NULL)
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01004750 return MODE_JSON;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004751 return channel->ch_part[part].ch_mode;
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01004752}
4753
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01004754/*
4755 * Return the timeout of "channel"/"part"
4756 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02004757 static int
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004758channel_get_timeout(channel_T *channel, ch_part_T part)
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01004759{
4760 return channel->ch_part[part].ch_timeout;
4761}
4762
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004763 static int
4764handle_mode(typval_T *item, jobopt_T *opt, ch_mode_T *modep, int jo)
4765{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004766 char_u *val = tv_get_string(item);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004767
4768 opt->jo_set |= jo;
4769 if (STRCMP(val, "nl") == 0)
4770 *modep = MODE_NL;
4771 else if (STRCMP(val, "raw") == 0)
4772 *modep = MODE_RAW;
4773 else if (STRCMP(val, "js") == 0)
4774 *modep = MODE_JS;
4775 else if (STRCMP(val, "json") == 0)
4776 *modep = MODE_JSON;
4777 else
4778 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004779 semsg(_(e_invarg2), val);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004780 return FAIL;
4781 }
4782 return OK;
4783}
4784
4785 static int
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004786handle_io(typval_T *item, ch_part_T part, jobopt_T *opt)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004787{
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004788 char_u *val = tv_get_string(item);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004789
4790 opt->jo_set |= JO_OUT_IO << (part - PART_OUT);
4791 if (STRCMP(val, "null") == 0)
4792 opt->jo_io[part] = JIO_NULL;
4793 else if (STRCMP(val, "pipe") == 0)
4794 opt->jo_io[part] = JIO_PIPE;
4795 else if (STRCMP(val, "file") == 0)
4796 opt->jo_io[part] = JIO_FILE;
4797 else if (STRCMP(val, "buffer") == 0)
4798 opt->jo_io[part] = JIO_BUFFER;
4799 else if (STRCMP(val, "out") == 0 && part == PART_ERR)
4800 opt->jo_io[part] = JIO_OUT;
4801 else
4802 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004803 semsg(_(e_invarg2), val);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004804 return FAIL;
4805 }
4806 return OK;
4807}
4808
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02004809/*
4810 * Clear a jobopt_T before using it.
4811 */
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004812 void
4813clear_job_options(jobopt_T *opt)
4814{
Bram Moolenaara80faa82020-04-12 19:37:17 +02004815 CLEAR_POINTER(opt);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004816}
4817
4818/*
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02004819 * Free any members of a jobopt_T.
4820 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02004821 static void
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02004822free_job_options(jobopt_T *opt)
4823{
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004824 if (opt->jo_callback.cb_partial != NULL)
4825 partial_unref(opt->jo_callback.cb_partial);
4826 else if (opt->jo_callback.cb_name != NULL)
4827 func_unref(opt->jo_callback.cb_name);
4828 if (opt->jo_out_cb.cb_partial != NULL)
4829 partial_unref(opt->jo_out_cb.cb_partial);
4830 else if (opt->jo_out_cb.cb_name != NULL)
4831 func_unref(opt->jo_out_cb.cb_name);
4832 if (opt->jo_err_cb.cb_partial != NULL)
4833 partial_unref(opt->jo_err_cb.cb_partial);
4834 else if (opt->jo_err_cb.cb_name != NULL)
4835 func_unref(opt->jo_err_cb.cb_name);
4836 if (opt->jo_close_cb.cb_partial != NULL)
4837 partial_unref(opt->jo_close_cb.cb_partial);
4838 else if (opt->jo_close_cb.cb_name != NULL)
4839 func_unref(opt->jo_close_cb.cb_name);
4840 if (opt->jo_exit_cb.cb_partial != NULL)
4841 partial_unref(opt->jo_exit_cb.cb_partial);
4842 else if (opt->jo_exit_cb.cb_name != NULL)
4843 func_unref(opt->jo_exit_cb.cb_name);
Bram Moolenaar05aafed2017-08-11 19:12:11 +02004844 if (opt->jo_env != NULL)
4845 dict_unref(opt->jo_env);
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02004846}
4847
4848/*
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004849 * Get the PART_ number from the first character of an option name.
4850 */
4851 static int
4852part_from_char(int c)
4853{
4854 return c == 'i' ? PART_IN : c == 'o' ? PART_OUT: PART_ERR;
4855}
4856
4857/*
4858 * Get the option entries from the dict in "tv", parse them and put the result
4859 * in "opt".
Bram Moolenaar08d384f2017-08-11 21:51:23 +02004860 * Only accept JO_ options in "supported" and JO2_ options in "supported2".
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004861 * If an option value is invalid return FAIL.
4862 */
4863 int
Bram Moolenaar08d384f2017-08-11 21:51:23 +02004864get_job_options(typval_T *tv, jobopt_T *opt, int supported, int supported2)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004865{
4866 typval_T *item;
4867 char_u *val;
4868 dict_T *dict;
4869 int todo;
4870 hashitem_T *hi;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004871 ch_part_T part;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004872
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004873 if (tv->v_type == VAR_UNKNOWN)
4874 return OK;
4875 if (tv->v_type != VAR_DICT)
4876 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004877 emsg(_(e_dictreq));
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004878 return FAIL;
4879 }
4880 dict = tv->vval.v_dict;
4881 if (dict == NULL)
4882 return OK;
4883
4884 todo = (int)dict->dv_hashtab.ht_used;
4885 for (hi = dict->dv_hashtab.ht_array; todo > 0; ++hi)
4886 if (!HASHITEM_EMPTY(hi))
4887 {
4888 item = &dict_lookup(hi)->di_tv;
4889
4890 if (STRCMP(hi->hi_key, "mode") == 0)
4891 {
4892 if (!(supported & JO_MODE))
4893 break;
4894 if (handle_mode(item, opt, &opt->jo_mode, JO_MODE) == FAIL)
4895 return FAIL;
4896 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01004897 else if (STRCMP(hi->hi_key, "in_mode") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004898 {
4899 if (!(supported & JO_IN_MODE))
4900 break;
4901 if (handle_mode(item, opt, &opt->jo_in_mode, JO_IN_MODE)
4902 == FAIL)
4903 return FAIL;
4904 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01004905 else if (STRCMP(hi->hi_key, "out_mode") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004906 {
4907 if (!(supported & JO_OUT_MODE))
4908 break;
4909 if (handle_mode(item, opt, &opt->jo_out_mode, JO_OUT_MODE)
4910 == FAIL)
4911 return FAIL;
4912 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01004913 else if (STRCMP(hi->hi_key, "err_mode") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004914 {
4915 if (!(supported & JO_ERR_MODE))
4916 break;
4917 if (handle_mode(item, opt, &opt->jo_err_mode, JO_ERR_MODE)
4918 == FAIL)
4919 return FAIL;
4920 }
Bram Moolenaar0b146882018-09-06 16:27:24 +02004921 else if (STRCMP(hi->hi_key, "noblock") == 0)
4922 {
4923 if (!(supported & JO_MODE))
4924 break;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004925 opt->jo_noblock = tv_get_number(item);
Bram Moolenaar0b146882018-09-06 16:27:24 +02004926 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01004927 else if (STRCMP(hi->hi_key, "in_io") == 0
4928 || STRCMP(hi->hi_key, "out_io") == 0
4929 || STRCMP(hi->hi_key, "err_io") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004930 {
4931 if (!(supported & JO_OUT_IO))
4932 break;
4933 if (handle_io(item, part_from_char(*hi->hi_key), opt) == FAIL)
4934 return FAIL;
4935 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01004936 else if (STRCMP(hi->hi_key, "in_name") == 0
4937 || STRCMP(hi->hi_key, "out_name") == 0
4938 || STRCMP(hi->hi_key, "err_name") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004939 {
4940 part = part_from_char(*hi->hi_key);
4941
4942 if (!(supported & JO_OUT_IO))
4943 break;
4944 opt->jo_set |= JO_OUT_NAME << (part - PART_OUT);
Bram Moolenaar21109272020-01-30 16:27:20 +01004945 opt->jo_io_name[part] = tv_get_string_buf_chk(item,
4946 opt->jo_io_name_buf[part]);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004947 }
Bram Moolenaar5a1feb82017-07-22 18:04:08 +02004948 else if (STRCMP(hi->hi_key, "pty") == 0)
4949 {
4950 if (!(supported & JO_MODE))
4951 break;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004952 opt->jo_pty = tv_get_number(item);
Bram Moolenaar5a1feb82017-07-22 18:04:08 +02004953 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01004954 else if (STRCMP(hi->hi_key, "in_buf") == 0
4955 || STRCMP(hi->hi_key, "out_buf") == 0
4956 || STRCMP(hi->hi_key, "err_buf") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004957 {
4958 part = part_from_char(*hi->hi_key);
4959
4960 if (!(supported & JO_OUT_IO))
4961 break;
4962 opt->jo_set |= JO_OUT_BUF << (part - PART_OUT);
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004963 opt->jo_io_buf[part] = tv_get_number(item);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004964 if (opt->jo_io_buf[part] <= 0)
4965 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004966 semsg(_(e_invargNval), hi->hi_key, tv_get_string(item));
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004967 return FAIL;
4968 }
4969 if (buflist_findnr(opt->jo_io_buf[part]) == NULL)
4970 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004971 semsg(_(e_nobufnr), (long)opt->jo_io_buf[part]);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004972 return FAIL;
4973 }
4974 }
Bram Moolenaar9f5842e2016-05-29 16:17:08 +02004975 else if (STRCMP(hi->hi_key, "out_modifiable") == 0
4976 || STRCMP(hi->hi_key, "err_modifiable") == 0)
4977 {
4978 part = part_from_char(*hi->hi_key);
4979
4980 if (!(supported & JO_OUT_IO))
4981 break;
4982 opt->jo_set |= JO_OUT_MODIFIABLE << (part - PART_OUT);
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004983 opt->jo_modifiable[part] = tv_get_number(item);
Bram Moolenaar9f5842e2016-05-29 16:17:08 +02004984 }
Bram Moolenaar169ebb02016-09-07 23:32:23 +02004985 else if (STRCMP(hi->hi_key, "out_msg") == 0
4986 || STRCMP(hi->hi_key, "err_msg") == 0)
4987 {
4988 part = part_from_char(*hi->hi_key);
4989
4990 if (!(supported & JO_OUT_IO))
4991 break;
4992 opt->jo_set2 |= JO2_OUT_MSG << (part - PART_OUT);
Bram Moolenaard155d7a2018-12-21 16:04:21 +01004993 opt->jo_message[part] = tv_get_number(item);
Bram Moolenaar169ebb02016-09-07 23:32:23 +02004994 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01004995 else if (STRCMP(hi->hi_key, "in_top") == 0
4996 || STRCMP(hi->hi_key, "in_bot") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004997 {
4998 linenr_T *lp;
4999
5000 if (!(supported & JO_OUT_IO))
5001 break;
5002 if (hi->hi_key[3] == 't')
5003 {
5004 lp = &opt->jo_in_top;
5005 opt->jo_set |= JO_IN_TOP;
5006 }
5007 else
5008 {
5009 lp = &opt->jo_in_bot;
5010 opt->jo_set |= JO_IN_BOT;
5011 }
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005012 *lp = tv_get_number(item);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005013 if (*lp < 0)
5014 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005015 semsg(_(e_invargNval), hi->hi_key, tv_get_string(item));
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005016 return FAIL;
5017 }
5018 }
5019 else if (STRCMP(hi->hi_key, "channel") == 0)
5020 {
5021 if (!(supported & JO_OUT_IO))
5022 break;
5023 opt->jo_set |= JO_CHANNEL;
5024 if (item->v_type != VAR_CHANNEL)
5025 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005026 semsg(_(e_invargval), "channel");
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005027 return FAIL;
5028 }
5029 opt->jo_channel = item->vval.v_channel;
5030 }
5031 else if (STRCMP(hi->hi_key, "callback") == 0)
5032 {
5033 if (!(supported & JO_CALLBACK))
5034 break;
5035 opt->jo_set |= JO_CALLBACK;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02005036 opt->jo_callback = get_callback(item);
5037 if (opt->jo_callback.cb_name == NULL)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005038 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005039 semsg(_(e_invargval), "callback");
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005040 return FAIL;
5041 }
5042 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01005043 else if (STRCMP(hi->hi_key, "out_cb") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005044 {
5045 if (!(supported & JO_OUT_CALLBACK))
5046 break;
5047 opt->jo_set |= JO_OUT_CALLBACK;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02005048 opt->jo_out_cb = get_callback(item);
5049 if (opt->jo_out_cb.cb_name == NULL)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005050 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005051 semsg(_(e_invargval), "out_cb");
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005052 return FAIL;
5053 }
5054 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01005055 else if (STRCMP(hi->hi_key, "err_cb") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005056 {
5057 if (!(supported & JO_ERR_CALLBACK))
5058 break;
5059 opt->jo_set |= JO_ERR_CALLBACK;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02005060 opt->jo_err_cb = get_callback(item);
5061 if (opt->jo_err_cb.cb_name == NULL)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005062 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005063 semsg(_(e_invargval), "err_cb");
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005064 return FAIL;
5065 }
5066 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01005067 else if (STRCMP(hi->hi_key, "close_cb") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005068 {
5069 if (!(supported & JO_CLOSE_CALLBACK))
5070 break;
5071 opt->jo_set |= JO_CLOSE_CALLBACK;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02005072 opt->jo_close_cb = get_callback(item);
5073 if (opt->jo_close_cb.cb_name == NULL)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005074 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005075 semsg(_(e_invargval), "close_cb");
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005076 return FAIL;
5077 }
5078 }
Bram Moolenaar958dc692016-12-01 15:34:12 +01005079 else if (STRCMP(hi->hi_key, "drop") == 0)
5080 {
5081 int never = FALSE;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005082 val = tv_get_string(item);
Bram Moolenaar958dc692016-12-01 15:34:12 +01005083
5084 if (STRCMP(val, "never") == 0)
5085 never = TRUE;
5086 else if (STRCMP(val, "auto") != 0)
5087 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005088 semsg(_(e_invargNval), "drop", val);
Bram Moolenaar958dc692016-12-01 15:34:12 +01005089 return FAIL;
5090 }
5091 opt->jo_drop_never = never;
5092 }
Bram Moolenaaref3abc62016-05-29 16:44:26 +02005093 else if (STRCMP(hi->hi_key, "exit_cb") == 0)
5094 {
5095 if (!(supported & JO_EXIT_CB))
5096 break;
5097 opt->jo_set |= JO_EXIT_CB;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02005098 opt->jo_exit_cb = get_callback(item);
5099 if (opt->jo_exit_cb.cb_name == NULL)
Bram Moolenaaref3abc62016-05-29 16:44:26 +02005100 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005101 semsg(_(e_invargval), "exit_cb");
Bram Moolenaaref3abc62016-05-29 16:44:26 +02005102 return FAIL;
5103 }
5104 }
Bram Moolenaar8456ea82017-08-05 15:02:05 +02005105#ifdef FEAT_TERMINAL
Bram Moolenaar78712a72017-08-05 14:50:12 +02005106 else if (STRCMP(hi->hi_key, "term_name") == 0)
5107 {
Bram Moolenaar08d384f2017-08-11 21:51:23 +02005108 if (!(supported2 & JO2_TERM_NAME))
Bram Moolenaar78712a72017-08-05 14:50:12 +02005109 break;
5110 opt->jo_set2 |= JO2_TERM_NAME;
Bram Moolenaar21109272020-01-30 16:27:20 +01005111 opt->jo_term_name = tv_get_string_buf_chk(item,
5112 opt->jo_term_name_buf);
Bram Moolenaar78712a72017-08-05 14:50:12 +02005113 if (opt->jo_term_name == NULL)
5114 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005115 semsg(_(e_invargval), "term_name");
Bram Moolenaar78712a72017-08-05 14:50:12 +02005116 return FAIL;
5117 }
5118 }
Bram Moolenaardd693ce2017-08-10 23:15:19 +02005119 else if (STRCMP(hi->hi_key, "term_finish") == 0)
5120 {
Bram Moolenaar08d384f2017-08-11 21:51:23 +02005121 if (!(supported2 & JO2_TERM_FINISH))
Bram Moolenaardd693ce2017-08-10 23:15:19 +02005122 break;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005123 val = tv_get_string(item);
Bram Moolenaardd693ce2017-08-10 23:15:19 +02005124 if (STRCMP(val, "open") != 0 && STRCMP(val, "close") != 0)
5125 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005126 semsg(_(e_invargNval), "term_finish", val);
Bram Moolenaardd693ce2017-08-10 23:15:19 +02005127 return FAIL;
5128 }
5129 opt->jo_set2 |= JO2_TERM_FINISH;
5130 opt->jo_term_finish = *val;
5131 }
Bram Moolenaar37c45832017-08-12 16:01:04 +02005132 else if (STRCMP(hi->hi_key, "term_opencmd") == 0)
5133 {
5134 char_u *p;
5135
5136 if (!(supported2 & JO2_TERM_OPENCMD))
5137 break;
5138 opt->jo_set2 |= JO2_TERM_OPENCMD;
Bram Moolenaar21109272020-01-30 16:27:20 +01005139 p = opt->jo_term_opencmd = tv_get_string_buf_chk(item,
5140 opt->jo_term_opencmd_buf);
Bram Moolenaar37c45832017-08-12 16:01:04 +02005141 if (p != NULL)
5142 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01005143 // Must have %d and no other %.
Bram Moolenaar37c45832017-08-12 16:01:04 +02005144 p = vim_strchr(p, '%');
5145 if (p != NULL && (p[1] != 'd'
5146 || vim_strchr(p + 2, '%') != NULL))
5147 p = NULL;
5148 }
5149 if (p == NULL)
5150 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005151 semsg(_(e_invargval), "term_opencmd");
Bram Moolenaar37c45832017-08-12 16:01:04 +02005152 return FAIL;
5153 }
5154 }
Bram Moolenaar3346cc42017-09-02 14:54:21 +02005155 else if (STRCMP(hi->hi_key, "eof_chars") == 0)
5156 {
Bram Moolenaar3346cc42017-09-02 14:54:21 +02005157 if (!(supported2 & JO2_EOF_CHARS))
5158 break;
5159 opt->jo_set2 |= JO2_EOF_CHARS;
Bram Moolenaar21109272020-01-30 16:27:20 +01005160 opt->jo_eof_chars = tv_get_string_buf_chk(item,
5161 opt->jo_eof_chars_buf);
5162 if (opt->jo_eof_chars == NULL)
Bram Moolenaar3346cc42017-09-02 14:54:21 +02005163 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005164 semsg(_(e_invargval), "eof_chars");
Bram Moolenaar3346cc42017-09-02 14:54:21 +02005165 return FAIL;
5166 }
Bram Moolenaar3346cc42017-09-02 14:54:21 +02005167 }
Bram Moolenaar08d384f2017-08-11 21:51:23 +02005168 else if (STRCMP(hi->hi_key, "term_rows") == 0)
5169 {
5170 if (!(supported2 & JO2_TERM_ROWS))
5171 break;
Bram Moolenaar25cdd9c2018-03-10 20:28:12 +01005172 opt->jo_set2 |= JO2_TERM_ROWS;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005173 opt->jo_term_rows = tv_get_number(item);
Bram Moolenaar08d384f2017-08-11 21:51:23 +02005174 }
5175 else if (STRCMP(hi->hi_key, "term_cols") == 0)
5176 {
5177 if (!(supported2 & JO2_TERM_COLS))
5178 break;
Bram Moolenaar25cdd9c2018-03-10 20:28:12 +01005179 opt->jo_set2 |= JO2_TERM_COLS;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005180 opt->jo_term_cols = tv_get_number(item);
Bram Moolenaar08d384f2017-08-11 21:51:23 +02005181 }
5182 else if (STRCMP(hi->hi_key, "vertical") == 0)
5183 {
5184 if (!(supported2 & JO2_VERTICAL))
5185 break;
Bram Moolenaar25cdd9c2018-03-10 20:28:12 +01005186 opt->jo_set2 |= JO2_VERTICAL;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005187 opt->jo_vertical = tv_get_number(item);
Bram Moolenaar08d384f2017-08-11 21:51:23 +02005188 }
Bram Moolenaarda43b612017-08-11 22:27:50 +02005189 else if (STRCMP(hi->hi_key, "curwin") == 0)
5190 {
5191 if (!(supported2 & JO2_CURWIN))
5192 break;
Bram Moolenaar25cdd9c2018-03-10 20:28:12 +01005193 opt->jo_set2 |= JO2_CURWIN;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005194 opt->jo_curwin = tv_get_number(item);
Bram Moolenaarda43b612017-08-11 22:27:50 +02005195 }
Bram Moolenaar87abab92019-06-03 21:14:59 +02005196 else if (STRCMP(hi->hi_key, "bufnr") == 0)
5197 {
5198 int nr;
5199
5200 if (!(supported2 & JO2_CURWIN))
5201 break;
5202 opt->jo_set2 |= JO2_BUFNR;
5203 nr = tv_get_number(item);
5204 if (nr <= 0)
5205 {
5206 semsg(_(e_invargNval), hi->hi_key, tv_get_string(item));
5207 return FAIL;
5208 }
5209 opt->jo_bufnr_buf = buflist_findnr(nr);
5210 if (opt->jo_bufnr_buf == NULL)
5211 {
5212 semsg(_(e_nobufnr), (long)nr);
5213 return FAIL;
5214 }
5215 if (opt->jo_bufnr_buf->b_nwindows == 0
5216 || opt->jo_bufnr_buf->b_term == NULL)
5217 {
5218 semsg(_(e_invarg2), "bufnr");
5219 return FAIL;
5220 }
5221 }
Bram Moolenaar8cad9302017-08-12 14:32:32 +02005222 else if (STRCMP(hi->hi_key, "hidden") == 0)
5223 {
5224 if (!(supported2 & JO2_HIDDEN))
5225 break;
Bram Moolenaar25cdd9c2018-03-10 20:28:12 +01005226 opt->jo_set2 |= JO2_HIDDEN;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005227 opt->jo_hidden = tv_get_number(item);
Bram Moolenaar8cad9302017-08-12 14:32:32 +02005228 }
Bram Moolenaar4d8bac82018-03-09 21:33:34 +01005229 else if (STRCMP(hi->hi_key, "norestore") == 0)
5230 {
5231 if (!(supported2 & JO2_NORESTORE))
5232 break;
Bram Moolenaar25cdd9c2018-03-10 20:28:12 +01005233 opt->jo_set2 |= JO2_NORESTORE;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005234 opt->jo_term_norestore = tv_get_number(item);
Bram Moolenaar4d8bac82018-03-09 21:33:34 +01005235 }
Bram Moolenaar25cdd9c2018-03-10 20:28:12 +01005236 else if (STRCMP(hi->hi_key, "term_kill") == 0)
5237 {
5238 if (!(supported2 & JO2_TERM_KILL))
5239 break;
5240 opt->jo_set2 |= JO2_TERM_KILL;
Bram Moolenaar21109272020-01-30 16:27:20 +01005241 opt->jo_term_kill = tv_get_string_buf_chk(item,
5242 opt->jo_term_kill_buf);
5243 if (opt->jo_term_kill == NULL)
5244 {
5245 semsg(_(e_invargval), "term_kill");
5246 return FAIL;
5247 }
Bram Moolenaar25cdd9c2018-03-10 20:28:12 +01005248 }
Bram Moolenaarc6ddce32019-02-08 12:47:03 +01005249 else if (STRCMP(hi->hi_key, "tty_type") == 0)
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01005250 {
5251 char_u *p;
5252
Bram Moolenaarc6ddce32019-02-08 12:47:03 +01005253 if (!(supported2 & JO2_TTY_TYPE))
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01005254 break;
Bram Moolenaarc6ddce32019-02-08 12:47:03 +01005255 opt->jo_set2 |= JO2_TTY_TYPE;
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01005256 p = tv_get_string_chk(item);
5257 if (p == NULL)
5258 {
Bram Moolenaarc6ddce32019-02-08 12:47:03 +01005259 semsg(_(e_invargval), "tty_type");
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01005260 return FAIL;
5261 }
5262 // Allow empty string, "winpty", "conpty".
5263 if (!(*p == NUL || STRCMP(p, "winpty") == 0
5264 || STRCMP(p, "conpty") == 0))
5265 {
Bram Moolenaarc6ddce32019-02-08 12:47:03 +01005266 semsg(_(e_invargval), "tty_type");
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01005267 return FAIL;
5268 }
Bram Moolenaarc6ddce32019-02-08 12:47:03 +01005269 opt->jo_tty_type = p[0];
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01005270 }
Bram Moolenaarf59c6e82018-04-10 15:59:11 +02005271# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
5272 else if (STRCMP(hi->hi_key, "ansi_colors") == 0)
5273 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005274 int n = 0;
Bram Moolenaarf59c6e82018-04-10 15:59:11 +02005275 listitem_T *li;
5276 long_u rgb[16];
5277
5278 if (!(supported2 & JO2_ANSI_COLORS))
5279 break;
5280
5281 if (item == NULL || item->v_type != VAR_LIST
5282 || item->vval.v_list == NULL)
5283 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005284 semsg(_(e_invargval), "ansi_colors");
Bram Moolenaarf59c6e82018-04-10 15:59:11 +02005285 return FAIL;
5286 }
5287
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02005288 CHECK_LIST_MATERIALIZE(item->vval.v_list);
Bram Moolenaarf59c6e82018-04-10 15:59:11 +02005289 li = item->vval.v_list->lv_first;
5290 for (; li != NULL && n < 16; li = li->li_next, n++)
5291 {
5292 char_u *color_name;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005293 guicolor_T guicolor;
Bram Moolenaar87202262020-05-24 17:23:45 +02005294 int called_emsg_before = called_emsg;
Bram Moolenaarf59c6e82018-04-10 15:59:11 +02005295
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005296 color_name = tv_get_string_chk(&li->li_tv);
Bram Moolenaarf59c6e82018-04-10 15:59:11 +02005297 if (color_name == NULL)
5298 return FAIL;
5299
5300 guicolor = GUI_GET_COLOR(color_name);
5301 if (guicolor == INVALCOLOR)
Bram Moolenaar87202262020-05-24 17:23:45 +02005302 {
5303 if (called_emsg_before == called_emsg)
5304 // may not get the error if the GUI didn't start
5305 semsg(_(e_alloc_color), color_name);
Bram Moolenaarf59c6e82018-04-10 15:59:11 +02005306 return FAIL;
Bram Moolenaar87202262020-05-24 17:23:45 +02005307 }
Bram Moolenaarf59c6e82018-04-10 15:59:11 +02005308
5309 rgb[n] = GUI_MCH_GET_RGB(guicolor);
5310 }
5311
5312 if (n != 16 || li != NULL)
5313 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005314 semsg(_(e_invargval), "ansi_colors");
Bram Moolenaarf59c6e82018-04-10 15:59:11 +02005315 return FAIL;
5316 }
5317
5318 opt->jo_set2 |= JO2_ANSI_COLORS;
5319 memcpy(opt->jo_ansi_colors, rgb, sizeof(rgb));
5320 }
5321# endif
Bram Moolenaar83d47902020-03-26 20:34:00 +01005322 else if (STRCMP(hi->hi_key, "term_highlight") == 0)
5323 {
5324 char_u *p;
5325
5326 if (!(supported2 & JO2_TERM_HIGHLIGHT))
5327 break;
5328 opt->jo_set2 |= JO2_TERM_HIGHLIGHT;
5329 p = tv_get_string_buf_chk(item, opt->jo_term_highlight_buf);
5330 if (p == NULL || *p == NUL)
5331 {
5332 semsg(_(e_invargval), "term_highlight");
5333 return FAIL;
5334 }
5335 opt->jo_term_highlight = p;
5336 }
Bram Moolenaard2842ea2019-09-26 23:08:54 +02005337 else if (STRCMP(hi->hi_key, "term_api") == 0)
5338 {
5339 if (!(supported2 & JO2_TERM_API))
5340 break;
5341 opt->jo_set2 |= JO2_TERM_API;
5342 opt->jo_term_api = tv_get_string_buf_chk(item,
Bram Moolenaar21109272020-01-30 16:27:20 +01005343 opt->jo_term_api_buf);
5344 if (opt->jo_term_api == NULL)
5345 {
5346 semsg(_(e_invargval), "term_api");
5347 return FAIL;
5348 }
Bram Moolenaard2842ea2019-09-26 23:08:54 +02005349 }
Bram Moolenaar8456ea82017-08-05 15:02:05 +02005350#endif
Bram Moolenaar05aafed2017-08-11 19:12:11 +02005351 else if (STRCMP(hi->hi_key, "env") == 0)
5352 {
Bram Moolenaar08d384f2017-08-11 21:51:23 +02005353 if (!(supported2 & JO2_ENV))
Bram Moolenaar05aafed2017-08-11 19:12:11 +02005354 break;
Bram Moolenaar22efba42018-04-07 13:22:21 +02005355 if (item->v_type != VAR_DICT)
5356 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005357 semsg(_(e_invargval), "env");
Bram Moolenaar22efba42018-04-07 13:22:21 +02005358 return FAIL;
5359 }
Bram Moolenaar25cdd9c2018-03-10 20:28:12 +01005360 opt->jo_set2 |= JO2_ENV;
Bram Moolenaar05aafed2017-08-11 19:12:11 +02005361 opt->jo_env = item->vval.v_dict;
Bram Moolenaar22efba42018-04-07 13:22:21 +02005362 if (opt->jo_env != NULL)
5363 ++opt->jo_env->dv_refcount;
Bram Moolenaar05aafed2017-08-11 19:12:11 +02005364 }
5365 else if (STRCMP(hi->hi_key, "cwd") == 0)
5366 {
Bram Moolenaar08d384f2017-08-11 21:51:23 +02005367 if (!(supported2 & JO2_CWD))
Bram Moolenaar05aafed2017-08-11 19:12:11 +02005368 break;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005369 opt->jo_cwd = tv_get_string_buf_chk(item, opt->jo_cwd_buf);
Bram Moolenaar839e81e2018-10-19 16:53:39 +02005370 if (opt->jo_cwd == NULL || !mch_isdir(opt->jo_cwd)
Bram Moolenaar4f974752019-02-17 17:44:42 +01005371#ifndef MSWIN // Win32 directories don't have the concept of "executable"
Bram Moolenaar42a4ea12018-10-19 17:36:01 +02005372 || mch_access((char *)opt->jo_cwd, X_OK) != 0
5373#endif
5374 )
Bram Moolenaar05aafed2017-08-11 19:12:11 +02005375 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005376 semsg(_(e_invargval), "cwd");
Bram Moolenaar05aafed2017-08-11 19:12:11 +02005377 return FAIL;
5378 }
Bram Moolenaar25cdd9c2018-03-10 20:28:12 +01005379 opt->jo_set2 |= JO2_CWD;
Bram Moolenaar05aafed2017-08-11 19:12:11 +02005380 }
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005381 else if (STRCMP(hi->hi_key, "waittime") == 0)
5382 {
5383 if (!(supported & JO_WAITTIME))
5384 break;
5385 opt->jo_set |= JO_WAITTIME;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005386 opt->jo_waittime = tv_get_number(item);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005387 }
5388 else if (STRCMP(hi->hi_key, "timeout") == 0)
5389 {
5390 if (!(supported & JO_TIMEOUT))
5391 break;
5392 opt->jo_set |= JO_TIMEOUT;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005393 opt->jo_timeout = tv_get_number(item);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005394 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01005395 else if (STRCMP(hi->hi_key, "out_timeout") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005396 {
5397 if (!(supported & JO_OUT_TIMEOUT))
5398 break;
5399 opt->jo_set |= JO_OUT_TIMEOUT;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005400 opt->jo_out_timeout = tv_get_number(item);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005401 }
Bram Moolenaard6c2f052016-03-14 23:22:59 +01005402 else if (STRCMP(hi->hi_key, "err_timeout") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005403 {
5404 if (!(supported & JO_ERR_TIMEOUT))
5405 break;
5406 opt->jo_set |= JO_ERR_TIMEOUT;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005407 opt->jo_err_timeout = tv_get_number(item);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005408 }
5409 else if (STRCMP(hi->hi_key, "part") == 0)
5410 {
5411 if (!(supported & JO_PART))
5412 break;
5413 opt->jo_set |= JO_PART;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005414 val = tv_get_string(item);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005415 if (STRCMP(val, "err") == 0)
5416 opt->jo_part = PART_ERR;
Bram Moolenaar7ef38102016-09-26 22:36:58 +02005417 else if (STRCMP(val, "out") == 0)
5418 opt->jo_part = PART_OUT;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005419 else
5420 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005421 semsg(_(e_invargNval), "part", val);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005422 return FAIL;
5423 }
5424 }
5425 else if (STRCMP(hi->hi_key, "id") == 0)
5426 {
5427 if (!(supported & JO_ID))
5428 break;
5429 opt->jo_set |= JO_ID;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005430 opt->jo_id = tv_get_number(item);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005431 }
5432 else if (STRCMP(hi->hi_key, "stoponexit") == 0)
5433 {
5434 if (!(supported & JO_STOPONEXIT))
5435 break;
5436 opt->jo_set |= JO_STOPONEXIT;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005437 opt->jo_stoponexit = tv_get_string_buf_chk(item,
Bram Moolenaar21109272020-01-30 16:27:20 +01005438 opt->jo_stoponexit_buf);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005439 if (opt->jo_stoponexit == NULL)
5440 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005441 semsg(_(e_invargval), "stoponexit");
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005442 return FAIL;
5443 }
5444 }
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02005445 else if (STRCMP(hi->hi_key, "block_write") == 0)
5446 {
5447 if (!(supported & JO_BLOCK_WRITE))
5448 break;
5449 opt->jo_set |= JO_BLOCK_WRITE;
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005450 opt->jo_block_write = tv_get_number(item);
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02005451 }
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005452 else
5453 break;
5454 --todo;
5455 }
5456 if (todo > 0)
5457 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005458 semsg(_(e_invarg2), hi->hi_key);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005459 return FAIL;
5460 }
5461
5462 return OK;
5463}
5464
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005465static job_T *first_job = NULL;
5466
5467 static void
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005468job_free_contents(job_T *job)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005469{
Bram Moolenaare1fc5152018-04-21 19:49:08 +02005470 int i;
5471
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005472 ch_log(job->jv_channel, "Freeing job");
5473 if (job->jv_channel != NULL)
5474 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01005475 // The link from the channel to the job doesn't count as a reference,
5476 // thus don't decrement the refcount of the job. The reference from
5477 // the job to the channel does count the reference, decrement it and
5478 // NULL the reference. We don't set ch_job_killed, unreferencing the
5479 // job doesn't mean it stops running.
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005480 job->jv_channel->ch_job = NULL;
5481 channel_unref(job->jv_channel);
5482 }
5483 mch_clear_job(job);
5484
Bram Moolenaar2dc9d262017-09-08 14:39:30 +02005485 vim_free(job->jv_tty_in);
5486 vim_free(job->jv_tty_out);
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005487 vim_free(job->jv_stoponexit);
Bram Moolenaarb3051ce2019-01-31 15:52:11 +01005488#ifdef UNIX
5489 vim_free(job->jv_termsig);
5490#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01005491#ifdef MSWIN
Bram Moolenaarc6ddce32019-02-08 12:47:03 +01005492 vim_free(job->jv_tty_type);
5493#endif
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02005494 free_callback(&job->jv_exit_cb);
Bram Moolenaar20608922018-04-21 22:30:08 +02005495 if (job->jv_argv != NULL)
Bram Moolenaare1fc5152018-04-21 19:49:08 +02005496 {
Bram Moolenaar20608922018-04-21 22:30:08 +02005497 for (i = 0; job->jv_argv[i] != NULL; i++)
5498 vim_free(job->jv_argv[i]);
5499 vim_free(job->jv_argv);
Bram Moolenaare1fc5152018-04-21 19:49:08 +02005500 }
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005501}
5502
Bram Moolenaar2a4857a2019-01-29 22:29:07 +01005503/*
5504 * Remove "job" from the list of jobs.
5505 */
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005506 static void
Bram Moolenaar2a4857a2019-01-29 22:29:07 +01005507job_unlink(job_T *job)
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005508{
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005509 if (job->jv_next != NULL)
5510 job->jv_next->jv_prev = job->jv_prev;
5511 if (job->jv_prev == NULL)
5512 first_job = job->jv_next;
5513 else
5514 job->jv_prev->jv_next = job->jv_next;
Bram Moolenaar2a4857a2019-01-29 22:29:07 +01005515}
5516
5517 static void
5518job_free_job(job_T *job)
5519{
5520 job_unlink(job);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005521 vim_free(job);
5522}
5523
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005524 static void
5525job_free(job_T *job)
5526{
5527 if (!in_free_unref_items)
5528 {
5529 job_free_contents(job);
5530 job_free_job(job);
5531 }
5532}
5533
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02005534static job_T *jobs_to_free = NULL;
Bram Moolenaar2a4857a2019-01-29 22:29:07 +01005535
5536/*
5537 * Put "job" in a list to be freed later, when it's no longer referenced.
5538 */
5539 static void
5540job_free_later(job_T *job)
5541{
5542 job_unlink(job);
5543 job->jv_next = jobs_to_free;
5544 jobs_to_free = job;
5545}
5546
5547 static void
5548free_jobs_to_free_later(void)
5549{
5550 job_T *job;
5551
5552 while (jobs_to_free != NULL)
5553 {
5554 job = jobs_to_free;
5555 jobs_to_free = job->jv_next;
5556 job_free_contents(job);
5557 vim_free(job);
5558 }
5559}
5560
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005561#if defined(EXITFREE) || defined(PROTO)
5562 void
5563job_free_all(void)
5564{
5565 while (first_job != NULL)
5566 job_free(first_job);
Bram Moolenaar2a4857a2019-01-29 22:29:07 +01005567 free_jobs_to_free_later();
5568
5569# ifdef FEAT_TERMINAL
5570 free_unused_terminals();
5571# endif
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005572}
5573#endif
5574
5575/*
5576 * Return TRUE if we need to check if the process of "job" has ended.
5577 */
5578 static int
5579job_need_end_check(job_T *job)
5580{
5581 return job->jv_status == JOB_STARTED
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02005582 && (job->jv_stoponexit != NULL || job->jv_exit_cb.cb_name != NULL);
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005583}
5584
5585/*
5586 * Return TRUE if the channel of "job" is still useful.
5587 */
5588 static int
5589job_channel_still_useful(job_T *job)
5590{
5591 return job->jv_channel != NULL && channel_still_useful(job->jv_channel);
5592}
5593
5594/*
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02005595 * Return TRUE if the channel of "job" is closeable.
5596 */
5597 static int
5598job_channel_can_close(job_T *job)
5599{
5600 return job->jv_channel != NULL && channel_can_close(job->jv_channel);
5601}
5602
5603/*
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005604 * Return TRUE if the job should not be freed yet. Do not free the job when
5605 * it has not ended yet and there is a "stoponexit" flag, an exit callback
5606 * or when the associated channel will do something with the job output.
5607 */
5608 static int
5609job_still_useful(job_T *job)
5610{
5611 return job_need_end_check(job) || job_channel_still_useful(job);
5612}
5613
Bram Moolenaarafde13b2019-04-28 19:46:49 +02005614#if defined(GUI_MAY_FORK) || defined(GUI_MAY_SPAWN) || defined(PROTO)
Bram Moolenaarb0b98d52018-05-05 21:01:00 +02005615/*
5616 * Return TRUE when there is any running job that we care about.
5617 */
5618 int
5619job_any_running()
5620{
5621 job_T *job;
5622
Bram Moolenaaraeea7212020-04-02 18:50:46 +02005623 FOR_ALL_JOBS(job)
Bram Moolenaarb0b98d52018-05-05 21:01:00 +02005624 if (job_still_useful(job))
Bram Moolenaare65fffd2018-05-13 14:40:15 +02005625 {
5626 ch_log(NULL, "GUI not forking because a job is running");
Bram Moolenaarb0b98d52018-05-05 21:01:00 +02005627 return TRUE;
Bram Moolenaare65fffd2018-05-13 14:40:15 +02005628 }
Bram Moolenaarb0b98d52018-05-05 21:01:00 +02005629 return FALSE;
5630}
5631#endif
5632
Bram Moolenaardcaa6132017-08-13 17:13:09 +02005633#if !defined(USE_ARGV) || defined(PROTO)
5634/*
5635 * Escape one argument for an external command.
5636 * Returns the escaped string in allocated memory. NULL when out of memory.
5637 */
5638 static char_u *
5639win32_escape_arg(char_u *arg)
5640{
5641 int slen, dlen;
5642 int escaping = 0;
5643 int i;
5644 char_u *s, *d;
5645 char_u *escaped_arg;
5646 int has_spaces = FALSE;
5647
Bram Moolenaarc667da52019-11-30 20:52:27 +01005648 // First count the number of extra bytes required.
Bram Moolenaare85928a2017-08-27 13:10:10 +02005649 slen = (int)STRLEN(arg);
Bram Moolenaardcaa6132017-08-13 17:13:09 +02005650 dlen = slen;
5651 for (s = arg; *s != NUL; MB_PTR_ADV(s))
5652 {
5653 if (*s == '"' || *s == '\\')
5654 ++dlen;
5655 if (*s == ' ' || *s == '\t')
5656 has_spaces = TRUE;
5657 }
5658
5659 if (has_spaces)
5660 dlen += 2;
5661
5662 if (dlen == slen)
5663 return vim_strsave(arg);
5664
Bram Moolenaarc667da52019-11-30 20:52:27 +01005665 // Allocate memory for the result and fill it.
Bram Moolenaardcaa6132017-08-13 17:13:09 +02005666 escaped_arg = alloc(dlen + 1);
5667 if (escaped_arg == NULL)
5668 return NULL;
5669 memset(escaped_arg, 0, dlen+1);
5670
5671 d = escaped_arg;
5672
5673 if (has_spaces)
5674 *d++ = '"';
5675
5676 for (s = arg; *s != NUL;)
5677 {
5678 switch (*s)
5679 {
5680 case '"':
5681 for (i = 0; i < escaping; i++)
5682 *d++ = '\\';
5683 escaping = 0;
5684 *d++ = '\\';
5685 *d++ = *s++;
5686 break;
5687 case '\\':
5688 escaping++;
5689 *d++ = *s++;
5690 break;
5691 default:
5692 escaping = 0;
5693 MB_COPY_CHAR(s, d);
5694 break;
5695 }
5696 }
5697
Bram Moolenaarc667da52019-11-30 20:52:27 +01005698 // add terminating quote and finish with a NUL
Bram Moolenaardcaa6132017-08-13 17:13:09 +02005699 if (has_spaces)
5700 {
5701 for (i = 0; i < escaping; i++)
5702 *d++ = '\\';
5703 *d++ = '"';
5704 }
5705 *d = NUL;
5706
5707 return escaped_arg;
5708}
5709
5710/*
5711 * Build a command line from a list, taking care of escaping.
5712 * The result is put in gap->ga_data.
5713 * Returns FAIL when out of memory.
5714 */
5715 int
5716win32_build_cmd(list_T *l, garray_T *gap)
5717{
5718 listitem_T *li;
5719 char_u *s;
5720
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02005721 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaaraeea7212020-04-02 18:50:46 +02005722 FOR_ALL_LIST_ITEMS(l, li)
Bram Moolenaardcaa6132017-08-13 17:13:09 +02005723 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01005724 s = tv_get_string_chk(&li->li_tv);
Bram Moolenaardcaa6132017-08-13 17:13:09 +02005725 if (s == NULL)
5726 return FAIL;
5727 s = win32_escape_arg(s);
5728 if (s == NULL)
5729 return FAIL;
5730 ga_concat(gap, s);
5731 vim_free(s);
5732 if (li->li_next != NULL)
5733 ga_append(gap, ' ');
5734 }
5735 return OK;
5736}
5737#endif
5738
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005739/*
5740 * NOTE: Must call job_cleanup() only once right after the status of "job"
5741 * changed to JOB_ENDED (i.e. after job_status() returned "dead" first or
5742 * mch_detect_ended_job() returned non-NULL).
Bram Moolenaar2a4857a2019-01-29 22:29:07 +01005743 * If the job is no longer used it will be removed from the list of jobs, and
5744 * deleted a bit later.
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005745 */
Bram Moolenaar8f84c3a2017-07-22 16:14:44 +02005746 void
Bram Moolenaar97792de2016-10-15 18:36:49 +02005747job_cleanup(job_T *job)
5748{
5749 if (job->jv_status != JOB_ENDED)
5750 return;
5751
Bram Moolenaarc667da52019-11-30 20:52:27 +01005752 // Ready to cleanup the job.
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005753 job->jv_status = JOB_FINISHED;
5754
Bram Moolenaarc667da52019-11-30 20:52:27 +01005755 // When only channel-in is kept open, close explicitly.
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02005756 if (job->jv_channel != NULL)
5757 ch_close_part(job->jv_channel, PART_IN);
5758
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02005759 if (job->jv_exit_cb.cb_name != NULL)
Bram Moolenaar97792de2016-10-15 18:36:49 +02005760 {
5761 typval_T argv[3];
5762 typval_T rettv;
Bram Moolenaar97792de2016-10-15 18:36:49 +02005763
Bram Moolenaarc667da52019-11-30 20:52:27 +01005764 // Invoke the exit callback. Make sure the refcount is > 0.
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02005765 ch_log(job->jv_channel, "Invoking exit callback %s",
5766 job->jv_exit_cb.cb_name);
Bram Moolenaar97792de2016-10-15 18:36:49 +02005767 ++job->jv_refcount;
5768 argv[0].v_type = VAR_JOB;
5769 argv[0].vval.v_job = job;
5770 argv[1].v_type = VAR_NUMBER;
5771 argv[1].vval.v_number = job->jv_exitval;
Bram Moolenaarc6538bc2019-08-03 18:17:11 +02005772 call_callback(&job->jv_exit_cb, -1, &rettv, 2, argv);
Bram Moolenaar97792de2016-10-15 18:36:49 +02005773 clear_tv(&rettv);
5774 --job->jv_refcount;
5775 channel_need_redraw = TRUE;
5776 }
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005777
Bram Moolenaar8caa43d2019-02-20 22:45:06 +01005778 if (job->jv_channel != NULL && job->jv_channel->ch_anonymous_pipe)
5779 job->jv_channel->ch_killing = TRUE;
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01005780
Bram Moolenaar2a4857a2019-01-29 22:29:07 +01005781 // Do not free the job in case the close callback of the associated channel
5782 // isn't invoked yet and may get information by job_info().
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005783 if (job->jv_refcount == 0 && !job_channel_still_useful(job))
Bram Moolenaar2a4857a2019-01-29 22:29:07 +01005784 // The job was already unreferenced and the associated channel was
5785 // detached, now that it ended it can be freed. However, a caller might
5786 // still use it, thus free it a bit later.
5787 job_free_later(job);
Bram Moolenaar97792de2016-10-15 18:36:49 +02005788}
5789
Bram Moolenaarb8d49052016-05-01 14:22:16 +02005790/*
5791 * Mark references in jobs that are still useful.
5792 */
5793 int
5794set_ref_in_job(int copyID)
5795{
5796 int abort = FALSE;
5797 job_T *job;
5798 typval_T tv;
5799
Bram Moolenaar75a1a942019-06-20 03:45:36 +02005800 for (job = first_job; !abort && job != NULL; job = job->jv_next)
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005801 if (job_still_useful(job))
Bram Moolenaarb8d49052016-05-01 14:22:16 +02005802 {
5803 tv.v_type = VAR_JOB;
5804 tv.vval.v_job = job;
5805 abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL);
5806 }
5807 return abort;
5808}
5809
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005810/*
5811 * Dereference "job". Note that after this "job" may have been freed.
5812 */
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005813 void
5814job_unref(job_T *job)
5815{
5816 if (job != NULL && --job->jv_refcount <= 0)
5817 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01005818 // Do not free the job if there is a channel where the close callback
5819 // may get the job info.
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005820 if (!job_channel_still_useful(job))
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005821 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01005822 // Do not free the job when it has not ended yet and there is a
5823 // "stoponexit" flag or an exit callback.
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005824 if (!job_need_end_check(job))
5825 {
5826 job_free(job);
5827 }
5828 else if (job->jv_channel != NULL)
5829 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01005830 // Do remove the link to the channel, otherwise it hangs
5831 // around until Vim exits. See job_free() for refcount.
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005832 ch_log(job->jv_channel, "detaching channel from job");
5833 job->jv_channel->ch_job = NULL;
5834 channel_unref(job->jv_channel);
5835 job->jv_channel = NULL;
5836 }
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005837 }
5838 }
5839}
5840
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005841 int
5842free_unused_jobs_contents(int copyID, int mask)
5843{
5844 int did_free = FALSE;
5845 job_T *job;
5846
Bram Moolenaaraeea7212020-04-02 18:50:46 +02005847 FOR_ALL_JOBS(job)
Bram Moolenaarebf7dfa2016-04-14 12:46:51 +02005848 if ((job->jv_copyID & mask) != (copyID & mask)
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005849 && !job_still_useful(job))
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005850 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01005851 // Free the channel and ordinary items it contains, but don't
5852 // recurse into Lists, Dictionaries etc.
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005853 job_free_contents(job);
5854 did_free = TRUE;
Bram Moolenaar36e0f7d2016-05-08 13:21:12 +02005855 }
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005856 return did_free;
5857}
5858
5859 void
5860free_unused_jobs(int copyID, int mask)
5861{
5862 job_T *job;
5863 job_T *job_next;
5864
5865 for (job = first_job; job != NULL; job = job_next)
5866 {
5867 job_next = job->jv_next;
Bram Moolenaarebf7dfa2016-04-14 12:46:51 +02005868 if ((job->jv_copyID & mask) != (copyID & mask)
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005869 && !job_still_useful(job))
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005870 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01005871 // Free the job struct itself.
Bram Moolenaar107e1ee2016-04-08 17:07:19 +02005872 job_free_job(job);
5873 }
5874 }
5875}
5876
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005877/*
5878 * Allocate a job. Sets the refcount to one and sets options default.
5879 */
Bram Moolenaar8f84c3a2017-07-22 16:14:44 +02005880 job_T *
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005881job_alloc(void)
5882{
5883 job_T *job;
5884
Bram Moolenaarc799fe22019-05-28 23:08:19 +02005885 job = ALLOC_CLEAR_ONE(job_T);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005886 if (job != NULL)
5887 {
5888 job->jv_refcount = 1;
5889 job->jv_stoponexit = vim_strsave((char_u *)"term");
5890
5891 if (first_job != NULL)
5892 {
5893 first_job->jv_prev = job;
5894 job->jv_next = first_job;
5895 }
5896 first_job = job;
5897 }
5898 return job;
5899}
5900
5901 void
5902job_set_options(job_T *job, jobopt_T *opt)
5903{
5904 if (opt->jo_set & JO_STOPONEXIT)
5905 {
5906 vim_free(job->jv_stoponexit);
5907 if (opt->jo_stoponexit == NULL || *opt->jo_stoponexit == NUL)
5908 job->jv_stoponexit = NULL;
5909 else
5910 job->jv_stoponexit = vim_strsave(opt->jo_stoponexit);
5911 }
5912 if (opt->jo_set & JO_EXIT_CB)
5913 {
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02005914 free_callback(&job->jv_exit_cb);
5915 if (opt->jo_exit_cb.cb_name == NULL || *opt->jo_exit_cb.cb_name == NUL)
Bram Moolenaar1735bc92016-03-14 23:05:14 +01005916 {
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02005917 job->jv_exit_cb.cb_name = NULL;
5918 job->jv_exit_cb.cb_partial = NULL;
Bram Moolenaar1735bc92016-03-14 23:05:14 +01005919 }
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005920 else
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02005921 copy_callback(&job->jv_exit_cb, &opt->jo_exit_cb);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005922 }
5923}
5924
5925/*
5926 * Called when Vim is exiting: kill all jobs that have the "stoponexit" flag.
5927 */
5928 void
Bram Moolenaarcf089462016-06-12 21:18:43 +02005929job_stop_on_exit(void)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005930{
5931 job_T *job;
5932
Bram Moolenaaraeea7212020-04-02 18:50:46 +02005933 FOR_ALL_JOBS(job)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005934 if (job->jv_status == JOB_STARTED && job->jv_stoponexit != NULL)
Bram Moolenaar2d33e902017-08-11 16:31:54 +02005935 mch_signal_job(job, job->jv_stoponexit);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005936}
5937
5938/*
Bram Moolenaar01688ad2016-10-27 20:00:07 +02005939 * Return TRUE when there is any job that has an exit callback and might exit,
5940 * which means job_check_ended() should be called more often.
Bram Moolenaarcf7c11a2016-06-02 20:05:26 +02005941 */
5942 int
Bram Moolenaarcf089462016-06-12 21:18:43 +02005943has_pending_job(void)
Bram Moolenaarcf7c11a2016-06-02 20:05:26 +02005944{
5945 job_T *job;
5946
Bram Moolenaaraeea7212020-04-02 18:50:46 +02005947 FOR_ALL_JOBS(job)
Bram Moolenaarc667da52019-11-30 20:52:27 +01005948 // Only should check if the channel has been closed, if the channel is
5949 // open the job won't exit.
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02005950 if ((job->jv_status == JOB_STARTED && !job_channel_still_useful(job))
5951 || (job->jv_status == JOB_FINISHED
5952 && job_channel_can_close(job)))
Bram Moolenaarcf7c11a2016-06-02 20:05:26 +02005953 return TRUE;
5954 return FALSE;
5955}
5956
Bram Moolenaar97792de2016-10-15 18:36:49 +02005957#define MAX_CHECK_ENDED 8
5958
Bram Moolenaarcf7c11a2016-06-02 20:05:26 +02005959/*
Bram Moolenaar36e0f7d2016-05-08 13:21:12 +02005960 * Called once in a while: check if any jobs that seem useful have ended.
Bram Moolenaarcd1a62d2018-12-14 21:32:02 +01005961 * Returns TRUE if a job did end.
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005962 */
Bram Moolenaarcd1a62d2018-12-14 21:32:02 +01005963 int
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005964job_check_ended(void)
5965{
Bram Moolenaar97792de2016-10-15 18:36:49 +02005966 int i;
Bram Moolenaarcd1a62d2018-12-14 21:32:02 +01005967 int did_end = FALSE;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005968
Bram Moolenaarcd1a62d2018-12-14 21:32:02 +01005969 // be quick if there are no jobs to check
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005970 if (first_job == NULL)
Bram Moolenaarcd1a62d2018-12-14 21:32:02 +01005971 return did_end;
Bram Moolenaar7df915d2016-11-17 17:25:32 +01005972
Bram Moolenaar97792de2016-10-15 18:36:49 +02005973 for (i = 0; i < MAX_CHECK_ENDED; ++i)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005974 {
Bram Moolenaarcd1a62d2018-12-14 21:32:02 +01005975 // NOTE: mch_detect_ended_job() must only return a job of which the
5976 // status was just set to JOB_ENDED.
Bram Moolenaar97792de2016-10-15 18:36:49 +02005977 job_T *job = mch_detect_ended_job(first_job);
5978
5979 if (job == NULL)
5980 break;
Bram Moolenaarcd1a62d2018-12-14 21:32:02 +01005981 did_end = TRUE;
Bram Moolenaar2a4857a2019-01-29 22:29:07 +01005982 job_cleanup(job); // may add "job" to jobs_to_free
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005983 }
Bram Moolenaar97792de2016-10-15 18:36:49 +02005984
Bram Moolenaar2a4857a2019-01-29 22:29:07 +01005985 // Actually free jobs that were cleaned up.
5986 free_jobs_to_free_later();
5987
Bram Moolenaarcf7c11a2016-06-02 20:05:26 +02005988 if (channel_need_redraw)
5989 {
5990 channel_need_redraw = FALSE;
Bram Moolenaar02e177d2017-08-26 23:43:28 +02005991 redraw_after_callback(TRUE);
Bram Moolenaarcf7c11a2016-06-02 20:05:26 +02005992 }
Bram Moolenaarcd1a62d2018-12-14 21:32:02 +01005993 return did_end;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01005994}
5995
5996/*
Bram Moolenaar96ca27a2017-07-17 23:20:24 +02005997 * Create a job and return it. Implements job_start().
Bram Moolenaar13568252018-03-16 20:46:58 +01005998 * "argv_arg" is only for Unix.
5999 * When "argv_arg" is NULL then "argvars" is used.
Bram Moolenaar96ca27a2017-07-17 23:20:24 +02006000 * The returned job has a refcount of one.
6001 * Returns NULL when out of memory.
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006002 */
6003 job_T *
Bram Moolenaar493359e2018-06-12 20:25:52 +02006004job_start(
6005 typval_T *argvars,
Bram Moolenaarbd67aac2019-09-21 23:09:04 +02006006 char **argv_arg UNUSED,
Bram Moolenaar493359e2018-06-12 20:25:52 +02006007 jobopt_T *opt_arg,
Bram Moolenaar21109272020-01-30 16:27:20 +01006008 job_T **term_job)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006009{
6010 job_T *job;
6011 char_u *cmd = NULL;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006012 char **argv = NULL;
6013 int argc = 0;
Bram Moolenaar538feb52020-01-20 21:59:39 +01006014 int i;
Bram Moolenaar20608922018-04-21 22:30:08 +02006015#if defined(UNIX)
6016# define USE_ARGV
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006017#else
6018 garray_T ga;
6019#endif
6020 jobopt_T opt;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02006021 ch_part_T part;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006022
6023 job = job_alloc();
6024 if (job == NULL)
6025 return NULL;
6026
6027 job->jv_status = JOB_FAILED;
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02006028#ifndef USE_ARGV
6029 ga_init2(&ga, (int)sizeof(char*), 20);
6030#endif
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006031
Bram Moolenaarcb8bbe92017-07-16 13:48:22 +02006032 if (opt_arg != NULL)
6033 opt = *opt_arg;
6034 else
6035 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01006036 // Default mode is NL.
Bram Moolenaarcb8bbe92017-07-16 13:48:22 +02006037 clear_job_options(&opt);
6038 opt.jo_mode = MODE_NL;
6039 if (get_job_options(&argvars[1], &opt,
Bram Moolenaar8ed54002017-08-11 22:22:36 +02006040 JO_MODE_ALL + JO_CB_ALL + JO_TIMEOUT_ALL + JO_STOPONEXIT
6041 + JO_EXIT_CB + JO_OUT_IO + JO_BLOCK_WRITE,
6042 JO2_ENV + JO2_CWD) == FAIL)
Bram Moolenaar3c3a80d2017-08-03 17:06:45 +02006043 goto theend;
Bram Moolenaarcb8bbe92017-07-16 13:48:22 +02006044 }
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006045
Bram Moolenaarc667da52019-11-30 20:52:27 +01006046 // Check that when io is "file" that there is a file name.
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02006047 for (part = PART_OUT; part < PART_COUNT; ++part)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006048 if ((opt.jo_set & (JO_OUT_IO << (part - PART_OUT)))
6049 && opt.jo_io[part] == JIO_FILE
6050 && (!(opt.jo_set & (JO_OUT_NAME << (part - PART_OUT)))
6051 || *opt.jo_io_name[part] == NUL))
6052 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006053 emsg(_("E920: _io file requires _name to be set"));
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02006054 goto theend;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006055 }
6056
6057 if ((opt.jo_set & JO_IN_IO) && opt.jo_io[PART_IN] == JIO_BUFFER)
6058 {
6059 buf_T *buf = NULL;
6060
Bram Moolenaarc667da52019-11-30 20:52:27 +01006061 // check that we can find the buffer before starting the job
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006062 if (opt.jo_set & JO_IN_BUF)
6063 {
6064 buf = buflist_findnr(opt.jo_io_buf[PART_IN]);
6065 if (buf == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006066 semsg(_(e_nobufnr), (long)opt.jo_io_buf[PART_IN]);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006067 }
6068 else if (!(opt.jo_set & JO_IN_NAME))
6069 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006070 emsg(_("E915: in_io buffer requires in_buf or in_name to be set"));
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006071 }
6072 else
6073 buf = buflist_find_by_name(opt.jo_io_name[PART_IN], FALSE);
6074 if (buf == NULL)
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02006075 goto theend;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006076 if (buf->b_ml.ml_mfp == NULL)
6077 {
6078 char_u numbuf[NUMBUFLEN];
6079 char_u *s;
6080
6081 if (opt.jo_set & JO_IN_BUF)
6082 {
6083 sprintf((char *)numbuf, "%d", opt.jo_io_buf[PART_IN]);
6084 s = numbuf;
6085 }
6086 else
6087 s = opt.jo_io_name[PART_IN];
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006088 semsg(_("E918: buffer must be loaded: %s"), s);
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02006089 goto theend;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006090 }
6091 job->jv_in_buf = buf;
6092 }
6093
6094 job_set_options(job, &opt);
6095
Bram Moolenaar13568252018-03-16 20:46:58 +01006096#ifdef USE_ARGV
6097 if (argv_arg != NULL)
6098 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01006099 // Make a copy of argv_arg for job->jv_argv.
Bram Moolenaar20608922018-04-21 22:30:08 +02006100 for (i = 0; argv_arg[i] != NULL; i++)
6101 argc++;
Bram Moolenaarc799fe22019-05-28 23:08:19 +02006102 argv = ALLOC_MULT(char *, argc + 1);
Bram Moolenaar20608922018-04-21 22:30:08 +02006103 if (argv == NULL)
6104 goto theend;
6105 for (i = 0; i < argc; i++)
6106 argv[i] = (char *)vim_strsave((char_u *)argv_arg[i]);
6107 argv[argc] = NULL;
Bram Moolenaar13568252018-03-16 20:46:58 +01006108 }
6109 else
6110#endif
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006111 if (argvars[0].v_type == VAR_STRING)
6112 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01006113 // Command is a string.
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006114 cmd = argvars[0].vval.v_string;
Bram Moolenaar7c2a2f82019-12-22 18:28:51 +01006115 if (cmd == NULL || *skipwhite(cmd) == NUL)
Bram Moolenaar80385682016-03-27 19:13:35 +02006116 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006117 emsg(_(e_invarg));
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02006118 goto theend;
Bram Moolenaar80385682016-03-27 19:13:35 +02006119 }
Bram Moolenaarebe74b72018-04-21 23:34:43 +02006120
6121 if (build_argv_from_string(cmd, &argv, &argc) == FAIL)
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02006122 goto theend;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006123 }
6124 else if (argvars[0].v_type != VAR_LIST
6125 || argvars[0].vval.v_list == NULL
6126 || argvars[0].vval.v_list->lv_len < 1)
6127 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006128 emsg(_(e_invarg));
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02006129 goto theend;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006130 }
6131 else
6132 {
Bram Moolenaarebe74b72018-04-21 23:34:43 +02006133 list_T *l = argvars[0].vval.v_list;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006134
Bram Moolenaarebe74b72018-04-21 23:34:43 +02006135 if (build_argv_from_list(l, &argv, &argc) == FAIL)
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02006136 goto theend;
Bram Moolenaarba0a7472019-12-22 16:09:06 +01006137
6138 // Empty command is invalid.
Bram Moolenaarba0a7472019-12-22 16:09:06 +01006139 if (argc == 0 || *skipwhite((char_u *)argv[0]) == NUL)
6140 {
6141 emsg(_(e_invarg));
6142 goto theend;
6143 }
Bram Moolenaar7c2a2f82019-12-22 18:28:51 +01006144#ifndef USE_ARGV
Bram Moolenaardcaa6132017-08-13 17:13:09 +02006145 if (win32_build_cmd(l, &ga) == FAIL)
6146 goto theend;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006147 cmd = ga.ga_data;
Bram Moolenaarba0a7472019-12-22 16:09:06 +01006148 if (cmd == NULL || *skipwhite(cmd) == NUL)
Bram Moolenaara27655e2019-12-21 22:22:01 +01006149 {
6150 emsg(_(e_invarg));
6151 goto theend;
6152 }
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006153#endif
6154 }
6155
Bram Moolenaarc667da52019-11-30 20:52:27 +01006156 // Save the command used to start the job.
Bram Moolenaarb2ed6802018-05-13 14:05:18 +02006157 job->jv_argv = argv;
Bram Moolenaare1fc5152018-04-21 19:49:08 +02006158
Bram Moolenaar21109272020-01-30 16:27:20 +01006159 if (term_job != NULL)
6160 *term_job = job;
6161
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006162#ifdef USE_ARGV
6163 if (ch_log_active())
6164 {
6165 garray_T ga;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006166
6167 ga_init2(&ga, (int)sizeof(char), 200);
6168 for (i = 0; i < argc; ++i)
6169 {
6170 if (i > 0)
6171 ga_concat(&ga, (char_u *)" ");
6172 ga_concat(&ga, (char_u *)argv[i]);
6173 }
Bram Moolenaar04af1962019-04-12 21:19:04 +02006174 ga_append(&ga, NUL);
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02006175 ch_log(NULL, "Starting job: %s", (char *)ga.ga_data);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006176 ga_clear(&ga);
6177 }
Bram Moolenaar21109272020-01-30 16:27:20 +01006178 mch_job_start(argv, job, &opt, term_job != NULL);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006179#else
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02006180 ch_log(NULL, "Starting job: %s", (char *)cmd);
Bram Moolenaar5a1feb82017-07-22 18:04:08 +02006181 mch_job_start((char *)cmd, job, &opt);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006182#endif
6183
Bram Moolenaarc667da52019-11-30 20:52:27 +01006184 // If the channel is reading from a buffer, write lines now.
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006185 if (job->jv_channel != NULL)
6186 channel_write_in(job->jv_channel);
6187
6188theend:
Bram Moolenaar20608922018-04-21 22:30:08 +02006189#ifndef USE_ARGV
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006190 vim_free(ga.ga_data);
6191#endif
Bram Moolenaar81c3ea72020-01-23 15:48:42 +01006192 if (argv != NULL && argv != job->jv_argv)
Bram Moolenaar538feb52020-01-20 21:59:39 +01006193 {
6194 for (i = 0; argv[i] != NULL; i++)
6195 vim_free(argv[i]);
Bram Moolenaar20608922018-04-21 22:30:08 +02006196 vim_free(argv);
Bram Moolenaar538feb52020-01-20 21:59:39 +01006197 }
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02006198 free_job_options(&opt);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006199 return job;
6200}
6201
6202/*
6203 * Get the status of "job" and invoke the exit callback when needed.
6204 * The returned string is not allocated.
6205 */
6206 char *
6207job_status(job_T *job)
6208{
6209 char *result;
6210
Bram Moolenaar7df915d2016-11-17 17:25:32 +01006211 if (job->jv_status >= JOB_ENDED)
Bram Moolenaarc667da52019-11-30 20:52:27 +01006212 // No need to check, dead is dead.
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006213 result = "dead";
6214 else if (job->jv_status == JOB_FAILED)
6215 result = "fail";
6216 else
6217 {
6218 result = mch_job_status(job);
6219 if (job->jv_status == JOB_ENDED)
Bram Moolenaar97792de2016-10-15 18:36:49 +02006220 job_cleanup(job);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006221 }
6222 return result;
6223}
6224
Bram Moolenaar8950a562016-03-12 15:22:55 +01006225/*
Bram Moolenaar96ca27a2017-07-17 23:20:24 +02006226 * Send a signal to "job". Implements job_stop().
6227 * When "type" is not NULL use this for the type.
6228 * Otherwise use argvars[1] for the type.
6229 */
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006230 int
Bram Moolenaar96ca27a2017-07-17 23:20:24 +02006231job_stop(job_T *job, typval_T *argvars, char *type)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006232{
6233 char_u *arg;
6234
Bram Moolenaar96ca27a2017-07-17 23:20:24 +02006235 if (type != NULL)
6236 arg = (char_u *)type;
6237 else if (argvars[1].v_type == VAR_UNKNOWN)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006238 arg = (char_u *)"";
6239 else
6240 {
Bram Moolenaard155d7a2018-12-21 16:04:21 +01006241 arg = tv_get_string_chk(&argvars[1]);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006242 if (arg == NULL)
6243 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006244 emsg(_(e_invarg));
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006245 return 0;
6246 }
6247 }
Bram Moolenaar61a66052017-07-22 18:39:00 +02006248 if (job->jv_status == JOB_FAILED)
6249 {
6250 ch_log(job->jv_channel, "Job failed to start, job_stop() skipped");
6251 return 0;
6252 }
Bram Moolenaar1a9020d2017-04-29 16:24:38 +02006253 if (job->jv_status == JOB_ENDED)
6254 {
6255 ch_log(job->jv_channel, "Job has already ended, job_stop() skipped");
6256 return 0;
6257 }
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02006258 ch_log(job->jv_channel, "Stopping job with '%s'", (char *)arg);
Bram Moolenaar2d33e902017-08-11 16:31:54 +02006259 if (mch_signal_job(job, arg) == FAIL)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006260 return 0;
6261
Bram Moolenaarc667da52019-11-30 20:52:27 +01006262 // Assume that only "kill" will kill the job.
Bram Moolenaar1a9020d2017-04-29 16:24:38 +02006263 if (job->jv_channel != NULL && STRCMP(arg, "kill") == 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006264 job->jv_channel->ch_job_killed = TRUE;
6265
Bram Moolenaarc667da52019-11-30 20:52:27 +01006266 // We don't try freeing the job, obviously the caller still has a
6267 // reference to it.
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01006268 return 1;
6269}
6270
Bram Moolenaarf2732452018-06-03 14:47:35 +02006271 void
6272invoke_prompt_callback(void)
6273{
6274 typval_T rettv;
Bram Moolenaarf2732452018-06-03 14:47:35 +02006275 typval_T argv[2];
6276 char_u *text;
6277 char_u *prompt;
6278 linenr_T lnum = curbuf->b_ml.ml_line_count;
6279
6280 // Add a new line for the prompt before invoking the callback, so that
6281 // text can always be inserted above the last line.
6282 ml_append(lnum, (char_u *)"", 0, FALSE);
6283 curwin->w_cursor.lnum = lnum + 1;
6284 curwin->w_cursor.col = 0;
6285
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02006286 if (curbuf->b_prompt_callback.cb_name == NULL
6287 || *curbuf->b_prompt_callback.cb_name == NUL)
Bram Moolenaarf2732452018-06-03 14:47:35 +02006288 return;
6289 text = ml_get(lnum);
6290 prompt = prompt_text();
6291 if (STRLEN(text) >= STRLEN(prompt))
6292 text += STRLEN(prompt);
6293 argv[0].v_type = VAR_STRING;
6294 argv[0].vval.v_string = vim_strsave(text);
6295 argv[1].v_type = VAR_UNKNOWN;
6296
Bram Moolenaarc6538bc2019-08-03 18:17:11 +02006297 call_callback(&curbuf->b_prompt_callback, -1, &rettv, 1, argv);
Bram Moolenaarf2732452018-06-03 14:47:35 +02006298 clear_tv(&argv[0]);
6299 clear_tv(&rettv);
6300}
6301
Bram Moolenaar0e5979a2018-06-17 19:36:33 +02006302/*
6303 * Return TRUE when the interrupt callback was invoked.
6304 */
6305 int
6306invoke_prompt_interrupt(void)
6307{
6308 typval_T rettv;
Bram Moolenaar0e5979a2018-06-17 19:36:33 +02006309 typval_T argv[1];
6310
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02006311 if (curbuf->b_prompt_interrupt.cb_name == NULL
6312 || *curbuf->b_prompt_interrupt.cb_name == NUL)
Bram Moolenaar0e5979a2018-06-17 19:36:33 +02006313 return FALSE;
6314 argv[0].v_type = VAR_UNKNOWN;
6315
6316 got_int = FALSE; // don't skip executing commands
Bram Moolenaarc6538bc2019-08-03 18:17:11 +02006317 call_callback(&curbuf->b_prompt_interrupt, -1, &rettv, 0, argv);
Bram Moolenaar0e5979a2018-06-17 19:36:33 +02006318 clear_tv(&rettv);
6319 return TRUE;
6320}
6321
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02006322/*
6323 * "prompt_setcallback({buffer}, {callback})" function
6324 */
6325 void
6326f_prompt_setcallback(typval_T *argvars, typval_T *rettv UNUSED)
6327{
6328 buf_T *buf;
6329 callback_T callback;
6330
6331 if (check_secure())
6332 return;
6333 buf = tv_get_buf(&argvars[0], FALSE);
6334 if (buf == NULL)
6335 return;
6336
6337 callback = get_callback(&argvars[1]);
6338 if (callback.cb_name == NULL)
6339 return;
6340
6341 free_callback(&buf->b_prompt_callback);
6342 set_callback(&buf->b_prompt_callback, &callback);
6343}
6344
6345/*
6346 * "prompt_setinterrupt({buffer}, {callback})" function
6347 */
6348 void
6349f_prompt_setinterrupt(typval_T *argvars, typval_T *rettv UNUSED)
6350{
6351 buf_T *buf;
6352 callback_T callback;
6353
6354 if (check_secure())
6355 return;
6356 buf = tv_get_buf(&argvars[0], FALSE);
6357 if (buf == NULL)
6358 return;
6359
6360 callback = get_callback(&argvars[1]);
6361 if (callback.cb_name == NULL)
6362 return;
6363
6364 free_callback(&buf->b_prompt_interrupt);
6365 set_callback(&buf->b_prompt_interrupt, &callback);
6366}
6367
6368/*
6369 * "prompt_setprompt({buffer}, {text})" function
6370 */
6371 void
6372f_prompt_setprompt(typval_T *argvars, typval_T *rettv UNUSED)
6373{
6374 buf_T *buf;
6375 char_u *text;
6376
6377 if (check_secure())
6378 return;
6379 buf = tv_get_buf(&argvars[0], FALSE);
6380 if (buf == NULL)
6381 return;
6382
6383 text = tv_get_string(&argvars[1]);
6384 vim_free(buf->b_prompt_text);
6385 buf->b_prompt_text = vim_strsave(text);
6386}
6387
6388/*
6389 * "ch_canread()" function
6390 */
6391 void
6392f_ch_canread(typval_T *argvars, typval_T *rettv)
6393{
6394 channel_T *channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
6395
6396 rettv->vval.v_number = 0;
6397 if (channel != NULL)
6398 rettv->vval.v_number = channel_has_readahead(channel, PART_SOCK)
6399 || channel_has_readahead(channel, PART_OUT)
6400 || channel_has_readahead(channel, PART_ERR);
6401}
6402
6403/*
6404 * "ch_close()" function
6405 */
6406 void
6407f_ch_close(typval_T *argvars, typval_T *rettv UNUSED)
6408{
6409 channel_T *channel = get_channel_arg(&argvars[0], TRUE, FALSE, 0);
6410
6411 if (channel != NULL)
6412 {
6413 channel_close(channel, FALSE);
6414 channel_clear(channel);
6415 }
6416}
6417
6418/*
6419 * "ch_close()" function
6420 */
6421 void
6422f_ch_close_in(typval_T *argvars, typval_T *rettv UNUSED)
6423{
6424 channel_T *channel = get_channel_arg(&argvars[0], TRUE, FALSE, 0);
6425
6426 if (channel != NULL)
6427 channel_close_in(channel);
6428}
6429
6430/*
6431 * "ch_getbufnr()" function
6432 */
6433 void
6434f_ch_getbufnr(typval_T *argvars, typval_T *rettv)
6435{
6436 channel_T *channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
6437
6438 rettv->vval.v_number = -1;
6439 if (channel != NULL)
6440 {
6441 char_u *what = tv_get_string(&argvars[1]);
6442 int part;
6443
6444 if (STRCMP(what, "err") == 0)
6445 part = PART_ERR;
6446 else if (STRCMP(what, "out") == 0)
6447 part = PART_OUT;
6448 else if (STRCMP(what, "in") == 0)
6449 part = PART_IN;
6450 else
6451 part = PART_SOCK;
6452 if (channel->ch_part[part].ch_bufref.br_buf != NULL)
6453 rettv->vval.v_number =
6454 channel->ch_part[part].ch_bufref.br_buf->b_fnum;
6455 }
6456}
6457
6458/*
6459 * "ch_getjob()" function
6460 */
6461 void
6462f_ch_getjob(typval_T *argvars, typval_T *rettv)
6463{
6464 channel_T *channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
6465
6466 if (channel != NULL)
6467 {
6468 rettv->v_type = VAR_JOB;
6469 rettv->vval.v_job = channel->ch_job;
6470 if (channel->ch_job != NULL)
6471 ++channel->ch_job->jv_refcount;
6472 }
6473}
6474
6475/*
6476 * "ch_info()" function
6477 */
6478 void
6479f_ch_info(typval_T *argvars, typval_T *rettv UNUSED)
6480{
6481 channel_T *channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
6482
6483 if (channel != NULL && rettv_dict_alloc(rettv) != FAIL)
6484 channel_info(channel, rettv->vval.v_dict);
6485}
6486
6487/*
6488 * "ch_log()" function
6489 */
6490 void
6491f_ch_log(typval_T *argvars, typval_T *rettv UNUSED)
6492{
6493 char_u *msg = tv_get_string(&argvars[0]);
6494 channel_T *channel = NULL;
6495
6496 if (argvars[1].v_type != VAR_UNKNOWN)
6497 channel = get_channel_arg(&argvars[1], FALSE, FALSE, 0);
6498
6499 ch_log(channel, "%s", msg);
6500}
6501
6502/*
6503 * "ch_logfile()" function
6504 */
6505 void
6506f_ch_logfile(typval_T *argvars, typval_T *rettv UNUSED)
6507{
6508 char_u *fname;
6509 char_u *opt = (char_u *)"";
6510 char_u buf[NUMBUFLEN];
6511
Bram Moolenaarc667da52019-11-30 20:52:27 +01006512 // Don't open a file in restricted mode.
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02006513 if (check_restricted() || check_secure())
6514 return;
6515 fname = tv_get_string(&argvars[0]);
6516 if (argvars[1].v_type == VAR_STRING)
6517 opt = tv_get_string_buf(&argvars[1], buf);
6518 ch_logfile(fname, opt);
6519}
6520
6521/*
6522 * "ch_open()" function
6523 */
6524 void
6525f_ch_open(typval_T *argvars, typval_T *rettv)
6526{
6527 rettv->v_type = VAR_CHANNEL;
6528 if (check_restricted() || check_secure())
6529 return;
6530 rettv->vval.v_channel = channel_open_func(argvars);
6531}
6532
6533/*
6534 * "ch_read()" function
6535 */
6536 void
6537f_ch_read(typval_T *argvars, typval_T *rettv)
6538{
6539 common_channel_read(argvars, rettv, FALSE, FALSE);
6540}
6541
6542/*
6543 * "ch_readblob()" function
6544 */
6545 void
6546f_ch_readblob(typval_T *argvars, typval_T *rettv)
6547{
6548 common_channel_read(argvars, rettv, TRUE, TRUE);
6549}
6550
6551/*
6552 * "ch_readraw()" function
6553 */
6554 void
6555f_ch_readraw(typval_T *argvars, typval_T *rettv)
6556{
6557 common_channel_read(argvars, rettv, TRUE, FALSE);
6558}
6559
6560/*
6561 * "ch_evalexpr()" function
6562 */
6563 void
6564f_ch_evalexpr(typval_T *argvars, typval_T *rettv)
6565{
6566 ch_expr_common(argvars, rettv, TRUE);
6567}
6568
6569/*
6570 * "ch_sendexpr()" function
6571 */
6572 void
6573f_ch_sendexpr(typval_T *argvars, typval_T *rettv)
6574{
6575 ch_expr_common(argvars, rettv, FALSE);
6576}
6577
6578/*
6579 * "ch_evalraw()" function
6580 */
6581 void
6582f_ch_evalraw(typval_T *argvars, typval_T *rettv)
6583{
6584 ch_raw_common(argvars, rettv, TRUE);
6585}
6586
6587/*
6588 * "ch_sendraw()" function
6589 */
6590 void
6591f_ch_sendraw(typval_T *argvars, typval_T *rettv)
6592{
6593 ch_raw_common(argvars, rettv, FALSE);
6594}
6595
6596/*
6597 * "ch_setoptions()" function
6598 */
6599 void
6600f_ch_setoptions(typval_T *argvars, typval_T *rettv UNUSED)
6601{
6602 channel_T *channel;
6603 jobopt_T opt;
6604
6605 channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
6606 if (channel == NULL)
6607 return;
6608 clear_job_options(&opt);
6609 if (get_job_options(&argvars[1], &opt,
6610 JO_CB_ALL + JO_TIMEOUT_ALL + JO_MODE_ALL, 0) == OK)
6611 channel_set_options(channel, &opt);
6612 free_job_options(&opt);
6613}
6614
6615/*
6616 * "ch_status()" function
6617 */
6618 void
6619f_ch_status(typval_T *argvars, typval_T *rettv)
6620{
6621 channel_T *channel;
6622 jobopt_T opt;
6623 int part = -1;
6624
Bram Moolenaarc667da52019-11-30 20:52:27 +01006625 // return an empty string by default
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02006626 rettv->v_type = VAR_STRING;
6627 rettv->vval.v_string = NULL;
6628
6629 channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
6630
6631 if (argvars[1].v_type != VAR_UNKNOWN)
6632 {
6633 clear_job_options(&opt);
6634 if (get_job_options(&argvars[1], &opt, JO_PART, 0) == OK
6635 && (opt.jo_set & JO_PART))
6636 part = opt.jo_part;
6637 }
6638
6639 rettv->vval.v_string = vim_strsave((char_u *)channel_status(channel, part));
6640}
6641
6642/*
6643 * Get the job from the argument.
6644 * Returns NULL if the job is invalid.
6645 */
6646 static job_T *
6647get_job_arg(typval_T *tv)
6648{
6649 job_T *job;
6650
6651 if (tv->v_type != VAR_JOB)
6652 {
6653 semsg(_(e_invarg2), tv_get_string(tv));
6654 return NULL;
6655 }
6656 job = tv->vval.v_job;
6657
6658 if (job == NULL)
6659 emsg(_("E916: not a valid job"));
6660 return job;
6661}
6662
6663/*
6664 * "job_getchannel()" function
6665 */
6666 void
6667f_job_getchannel(typval_T *argvars, typval_T *rettv)
6668{
6669 job_T *job = get_job_arg(&argvars[0]);
6670
6671 if (job != NULL)
6672 {
6673 rettv->v_type = VAR_CHANNEL;
6674 rettv->vval.v_channel = job->jv_channel;
6675 if (job->jv_channel != NULL)
6676 ++job->jv_channel->ch_refcount;
6677 }
6678}
6679
6680/*
6681 * Implementation of job_info().
6682 */
6683 static void
6684job_info(job_T *job, dict_T *dict)
6685{
6686 dictitem_T *item;
6687 varnumber_T nr;
6688 list_T *l;
6689 int i;
6690
6691 dict_add_string(dict, "status", (char_u *)job_status(job));
6692
6693 item = dictitem_alloc((char_u *)"channel");
6694 if (item == NULL)
6695 return;
6696 item->di_tv.v_type = VAR_CHANNEL;
6697 item->di_tv.vval.v_channel = job->jv_channel;
6698 if (job->jv_channel != NULL)
6699 ++job->jv_channel->ch_refcount;
6700 if (dict_add(dict, item) == FAIL)
6701 dictitem_free(item);
6702
6703#ifdef UNIX
6704 nr = job->jv_pid;
6705#else
6706 nr = job->jv_proc_info.dwProcessId;
6707#endif
6708 dict_add_number(dict, "process", nr);
6709 dict_add_string(dict, "tty_in", job->jv_tty_in);
6710 dict_add_string(dict, "tty_out", job->jv_tty_out);
6711
6712 dict_add_number(dict, "exitval", job->jv_exitval);
6713 dict_add_string(dict, "exit_cb", job->jv_exit_cb.cb_name);
6714 dict_add_string(dict, "stoponexit", job->jv_stoponexit);
6715#ifdef UNIX
6716 dict_add_string(dict, "termsig", job->jv_termsig);
6717#endif
6718#ifdef MSWIN
6719 dict_add_string(dict, "tty_type", job->jv_tty_type);
6720#endif
6721
6722 l = list_alloc();
6723 if (l != NULL)
6724 {
6725 dict_add_list(dict, "cmd", l);
6726 if (job->jv_argv != NULL)
6727 for (i = 0; job->jv_argv[i] != NULL; i++)
6728 list_append_string(l, (char_u *)job->jv_argv[i], -1);
6729 }
6730}
6731
6732/*
6733 * Implementation of job_info() to return info for all jobs.
6734 */
6735 static void
6736job_info_all(list_T *l)
6737{
6738 job_T *job;
6739 typval_T tv;
6740
Bram Moolenaaraeea7212020-04-02 18:50:46 +02006741 FOR_ALL_JOBS(job)
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02006742 {
6743 tv.v_type = VAR_JOB;
6744 tv.vval.v_job = job;
6745
6746 if (list_append_tv(l, &tv) != OK)
6747 return;
6748 }
6749}
6750
6751/*
6752 * "job_info()" function
6753 */
6754 void
6755f_job_info(typval_T *argvars, typval_T *rettv)
6756{
6757 if (argvars[0].v_type != VAR_UNKNOWN)
6758 {
6759 job_T *job = get_job_arg(&argvars[0]);
6760
6761 if (job != NULL && rettv_dict_alloc(rettv) != FAIL)
6762 job_info(job, rettv->vval.v_dict);
6763 }
6764 else if (rettv_list_alloc(rettv) == OK)
6765 job_info_all(rettv->vval.v_list);
6766}
6767
6768/*
6769 * "job_setoptions()" function
6770 */
6771 void
6772f_job_setoptions(typval_T *argvars, typval_T *rettv UNUSED)
6773{
6774 job_T *job = get_job_arg(&argvars[0]);
6775 jobopt_T opt;
6776
6777 if (job == NULL)
6778 return;
6779 clear_job_options(&opt);
6780 if (get_job_options(&argvars[1], &opt, JO_STOPONEXIT + JO_EXIT_CB, 0) == OK)
6781 job_set_options(job, &opt);
6782 free_job_options(&opt);
6783}
6784
6785/*
6786 * "job_start()" function
6787 */
6788 void
6789f_job_start(typval_T *argvars, typval_T *rettv)
6790{
6791 rettv->v_type = VAR_JOB;
6792 if (check_restricted() || check_secure())
6793 return;
Bram Moolenaar21109272020-01-30 16:27:20 +01006794 rettv->vval.v_job = job_start(argvars, NULL, NULL, NULL);
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02006795}
6796
6797/*
6798 * "job_status()" function
6799 */
6800 void
6801f_job_status(typval_T *argvars, typval_T *rettv)
6802{
6803 job_T *job = get_job_arg(&argvars[0]);
6804
6805 if (job != NULL)
6806 {
6807 rettv->v_type = VAR_STRING;
6808 rettv->vval.v_string = vim_strsave((char_u *)job_status(job));
6809 }
6810}
6811
6812/*
6813 * "job_stop()" function
6814 */
6815 void
6816f_job_stop(typval_T *argvars, typval_T *rettv)
6817{
6818 job_T *job = get_job_arg(&argvars[0]);
6819
6820 if (job != NULL)
6821 rettv->vval.v_number = job_stop(job, argvars, NULL);
6822}
6823
Bram Moolenaarc667da52019-11-30 20:52:27 +01006824#endif // FEAT_JOB_CHANNEL