blob: 5d89413503fc8f7d1a5375298544ada245dc4c4f [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);
Bram Moolenaarb2658a12016-04-26 17:16:24 +020069
Bram Moolenaaraeea7212020-04-02 18:50:46 +020070#define FOR_ALL_CHANNELS(ch) \
71 for ((ch) = first_channel; (ch) != NULL; (ch) = (ch)->ch_next)
72
Bram Moolenaarc667da52019-11-30 20:52:27 +010073// Whether we are inside channel_parse_messages() or another situation where it
74// is safe to invoke callbacks.
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +020075static int safe_to_invoke_callback = 0;
Bram Moolenaar187db502016-02-27 14:44:26 +010076
Bram Moolenaarde7eb0a2016-05-09 20:54:33 +020077static char *part_names[] = {"sock", "out", "err", "in"};
78
Bram Moolenaar4f974752019-02-17 17:44:42 +010079#ifdef MSWIN
Bram Moolenaard8070362016-02-15 21:56:54 +010080 static int
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +010081fd_read(sock_T fd, char *buf, size_t len)
Bram Moolenaard8070362016-02-15 21:56:54 +010082{
83 HANDLE h = (HANDLE)fd;
84 DWORD nread;
85
86 if (!ReadFile(h, buf, (DWORD)len, &nread, NULL))
87 return -1;
88 return (int)nread;
89}
90
91 static int
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +010092fd_write(sock_T fd, char *buf, size_t len)
Bram Moolenaard8070362016-02-15 21:56:54 +010093{
Bram Moolenaar24058382019-01-24 23:11:49 +010094 size_t todo = len;
Bram Moolenaarb091f302019-01-19 14:37:00 +010095 HANDLE h = (HANDLE)fd;
Bram Moolenaar24058382019-01-24 23:11:49 +010096 DWORD nwrite, size, done = 0;
Bram Moolenaarb091f302019-01-19 14:37:00 +010097 OVERLAPPED ov;
Bram Moolenaard8070362016-02-15 21:56:54 +010098
Bram Moolenaar24058382019-01-24 23:11:49 +010099 while (todo > 0)
Bram Moolenaarb091f302019-01-19 14:37:00 +0100100 {
Bram Moolenaar24058382019-01-24 23:11:49 +0100101 if (todo > MAX_NAMED_PIPE_SIZE)
102 size = MAX_NAMED_PIPE_SIZE;
103 else
Bram Moolenaardec01202019-01-28 20:04:24 +0100104 size = (DWORD)todo;
Bram Moolenaar65240682019-02-10 22:23:26 +0100105 // If the pipe overflows while the job does not read the data,
106 // WriteFile() will block forever. This abandons the write.
Bram Moolenaar24058382019-01-24 23:11:49 +0100107 memset(&ov, 0, sizeof(ov));
Bram Moolenaar65240682019-02-10 22:23:26 +0100108 nwrite = 0;
Bram Moolenaar24058382019-01-24 23:11:49 +0100109 if (!WriteFile(h, buf + done, size, &nwrite, &ov))
110 {
111 DWORD err = GetLastError();
Bram Moolenaarb091f302019-01-19 14:37:00 +0100112
Bram Moolenaar24058382019-01-24 23:11:49 +0100113 if (err != ERROR_IO_PENDING)
114 return -1;
115 if (!GetOverlappedResult(h, &ov, &nwrite, FALSE))
116 return -1;
117 FlushFileBuffers(h);
118 }
Bram Moolenaar65240682019-02-10 22:23:26 +0100119 else if (nwrite == 0)
120 // WriteFile() returns TRUE but did not write anything. This causes
121 // a hang, so bail out.
122 break;
Bram Moolenaar24058382019-01-24 23:11:49 +0100123 todo -= nwrite;
124 done += nwrite;
Bram Moolenaarb091f302019-01-19 14:37:00 +0100125 }
Bram Moolenaar24058382019-01-24 23:11:49 +0100126 return (int)done;
Bram Moolenaard8070362016-02-15 21:56:54 +0100127}
128
129 static void
130fd_close(sock_T fd)
131{
132 HANDLE h = (HANDLE)fd;
133
134 CloseHandle(h);
135}
136#endif
Bram Moolenaare0874f82016-01-24 20:36:41 +0100137
Bram Moolenaarc667da52019-11-30 20:52:27 +0100138// Log file opened with ch_logfile().
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100139static FILE *log_fd = NULL;
Bram Moolenaar76603ba2020-08-30 17:24:37 +0200140static char_u *log_name = NULL;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100141#ifdef FEAT_RELTIME
142static proftime_T log_start;
143#endif
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100144
145 void
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100146ch_logfile(char_u *fname, char_u *opt)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100147{
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100148 FILE *file = NULL;
149
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100150 if (log_fd != NULL)
Bram Moolenaar2e47cab2019-09-27 23:12:45 +0200151 {
152 if (*fname != NUL)
Bram Moolenaar03a9f842020-05-13 13:40:16 +0200153 ch_log(NULL, "closing this logfile, opening %s", fname);
Bram Moolenaar2e47cab2019-09-27 23:12:45 +0200154 else
Bram Moolenaar76603ba2020-08-30 17:24:37 +0200155 ch_log(NULL, "closing logfile %s", log_name);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100156 fclose(log_fd);
Bram Moolenaar2e47cab2019-09-27 23:12:45 +0200157 }
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100158
159 if (*fname != NUL)
160 {
161 file = fopen((char *)fname, *opt == 'w' ? "w" : "a");
162 if (file == NULL)
163 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100164 semsg(_(e_notopen), fname);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100165 return;
166 }
Bram Moolenaar76603ba2020-08-30 17:24:37 +0200167 vim_free(log_name);
168 log_name = vim_strsave(fname);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100169 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100170 log_fd = file;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100171
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100172 if (log_fd != NULL)
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100173 {
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100174 fprintf(log_fd, "==== start log session ====\n");
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100175#ifdef FEAT_RELTIME
176 profile_start(&log_start);
177#endif
178 }
179}
180
181 int
Bram Moolenaarcf089462016-06-12 21:18:43 +0200182ch_log_active(void)
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100183{
184 return log_fd != NULL;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100185}
186
187 static void
Bram Moolenaar4b16ee72018-08-09 22:15:34 +0200188ch_log_lead(const char *what, channel_T *ch, ch_part_T part)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100189{
190 if (log_fd != NULL)
191 {
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100192#ifdef FEAT_RELTIME
193 proftime_T log_now;
194
195 profile_start(&log_now);
196 profile_sub(&log_now, &log_start);
197 fprintf(log_fd, "%s ", profile_msg(&log_now));
198#endif
Bram Moolenaar77073442016-02-13 23:23:53 +0100199 if (ch != NULL)
Bram Moolenaar4b16ee72018-08-09 22:15:34 +0200200 {
201 if (part < PART_COUNT)
202 fprintf(log_fd, "%son %d(%s): ",
203 what, ch->ch_id, part_names[part]);
204 else
205 fprintf(log_fd, "%son %d: ", what, ch->ch_id);
206 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100207 else
208 fprintf(log_fd, "%s: ", what);
209 }
210}
211
Bram Moolenaar8caa43d2019-02-20 22:45:06 +0100212#ifndef PROTO // prototype is in proto.h
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100213 void
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200214ch_log(channel_T *ch, const char *fmt, ...)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100215{
216 if (log_fd != NULL)
217 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200218 va_list ap;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100219
Bram Moolenaar4b16ee72018-08-09 22:15:34 +0200220 ch_log_lead("", ch, PART_COUNT);
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200221 va_start(ap, fmt);
222 vfprintf(log_fd, fmt, ap);
223 va_end(ap);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100224 fputc('\n', log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100225 fflush(log_fd);
Bram Moolenaar101e9922019-09-25 21:43:11 +0200226 did_repeated_msg = 0;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100227 }
228}
Bram Moolenaar4ac2e8d2018-04-08 12:38:26 +0200229#endif
230
231 static void
232ch_error(channel_T *ch, const char *fmt, ...)
Bram Moolenaare80757c2018-04-10 12:42:44 +0200233#ifdef USE_PRINTF_FORMAT_ATTRIBUTE
234 __attribute__((format(printf, 2, 3)))
Bram Moolenaar4ac2e8d2018-04-08 12:38:26 +0200235#endif
236 ;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100237
238 static void
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200239ch_error(channel_T *ch, const char *fmt, ...)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100240{
241 if (log_fd != NULL)
242 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200243 va_list ap;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100244
Bram Moolenaar4b16ee72018-08-09 22:15:34 +0200245 ch_log_lead("ERR ", ch, PART_COUNT);
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200246 va_start(ap, fmt);
247 vfprintf(log_fd, fmt, ap);
248 va_end(ap);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100249 fputc('\n', log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100250 fflush(log_fd);
Bram Moolenaar101e9922019-09-25 21:43:11 +0200251 did_repeated_msg = 0;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100252 }
253}
Bram Moolenaard04a0202016-01-26 23:30:18 +0100254
Bram Moolenaar4f974752019-02-17 17:44:42 +0100255#ifdef MSWIN
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100256# undef PERROR
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100257# define PERROR(msg) (void)semsg("%s: %s", msg, strerror_win32(errno))
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100258
259 static char *
260strerror_win32(int eno)
261{
262 static LPVOID msgbuf = NULL;
263 char_u *ptr;
264
265 if (msgbuf)
Bram Moolenaaraad30bb2016-06-26 17:31:03 +0200266 {
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100267 LocalFree(msgbuf);
Bram Moolenaaraad30bb2016-06-26 17:31:03 +0200268 msgbuf = NULL;
269 }
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100270 FormatMessage(
271 FORMAT_MESSAGE_ALLOCATE_BUFFER |
272 FORMAT_MESSAGE_FROM_SYSTEM |
273 FORMAT_MESSAGE_IGNORE_INSERTS,
274 NULL,
275 eno,
276 MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),
277 (LPTSTR) &msgbuf,
278 0,
279 NULL);
Bram Moolenaaraad30bb2016-06-26 17:31:03 +0200280 if (msgbuf != NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100281 // chomp \r or \n
Bram Moolenaaraad30bb2016-06-26 17:31:03 +0200282 for (ptr = (char_u *)msgbuf; *ptr; ptr++)
283 switch (*ptr)
284 {
285 case '\r':
286 STRMOVE(ptr, ptr + 1);
287 ptr--;
288 break;
289 case '\n':
290 if (*(ptr + 1) == '\0')
291 *ptr = '\0';
292 else
293 *ptr = ' ';
294 break;
295 }
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100296 return msgbuf;
297}
298#endif
299
Bram Moolenaar77073442016-02-13 23:23:53 +0100300/*
301 * The list of all allocated channels.
302 */
303static channel_T *first_channel = NULL;
304static int next_ch_id = 0;
305
306/*
307 * Allocate a new channel. The refcount is set to 1.
308 * The channel isn't actually used until it is opened.
309 * Returns NULL if out of memory.
310 */
311 channel_T *
312add_channel(void)
Bram Moolenaare0874f82016-01-24 20:36:41 +0100313{
Bram Moolenaardc0ccae2016-10-09 17:28:01 +0200314 ch_part_T part;
Bram Moolenaarc799fe22019-05-28 23:08:19 +0200315 channel_T *channel = ALLOC_CLEAR_ONE(channel_T);
Bram Moolenaare0874f82016-01-24 20:36:41 +0100316
Bram Moolenaar77073442016-02-13 23:23:53 +0100317 if (channel == NULL)
318 return NULL;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100319
Bram Moolenaar77073442016-02-13 23:23:53 +0100320 channel->ch_id = next_ch_id++;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100321 ch_log(channel, "Created channel");
Bram Moolenaar77073442016-02-13 23:23:53 +0100322
Bram Moolenaardc0ccae2016-10-09 17:28:01 +0200323 for (part = PART_SOCK; part < PART_COUNT; ++part)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100324 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100325 channel->ch_part[part].ch_fd = INVALID_FD;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100326#ifdef FEAT_GUI_X11
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100327 channel->ch_part[part].ch_inputHandler = (XtInputId)NULL;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100328#endif
329#ifdef FEAT_GUI_GTK
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100330 channel->ch_part[part].ch_inputHandler = 0;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100331#endif
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100332 channel->ch_part[part].ch_timeout = 2000;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100333 }
Bram Moolenaare0874f82016-01-24 20:36:41 +0100334
Bram Moolenaar77073442016-02-13 23:23:53 +0100335 if (first_channel != NULL)
336 {
337 first_channel->ch_prev = channel;
338 channel->ch_next = first_channel;
339 }
340 first_channel = channel;
341
342 channel->ch_refcount = 1;
343 return channel;
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100344}
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100345
Bram Moolenaarb9c31e72016-09-29 15:18:57 +0200346 int
347has_any_channel(void)
348{
349 return first_channel != NULL;
350}
351
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100352/*
Bram Moolenaard6051b52016-02-28 15:49:03 +0100353 * Called when the refcount of a channel is zero.
Bram Moolenaar46c85432016-02-26 11:17:46 +0100354 * Return TRUE if "channel" has a callback and the associated job wasn't
355 * killed.
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100356 */
Bram Moolenaar8b5866d2020-09-05 15:48:51 +0200357 int
Bram Moolenaar46c85432016-02-26 11:17:46 +0100358channel_still_useful(channel_T *channel)
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100359{
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100360 int has_sock_msg;
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100361 int has_out_msg;
362 int has_err_msg;
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100363
Bram Moolenaarc667da52019-11-30 20:52:27 +0100364 // If the job was killed the channel is not expected to work anymore.
Bram Moolenaar46c85432016-02-26 11:17:46 +0100365 if (channel->ch_job_killed && channel->ch_job == NULL)
366 return FALSE;
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100367
Bram Moolenaarc667da52019-11-30 20:52:27 +0100368 // If there is a close callback it may still need to be invoked.
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200369 if (channel->ch_close_cb.cb_name != NULL)
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100370 return TRUE;
371
Bram Moolenaarc667da52019-11-30 20:52:27 +0100372 // If reading from or a buffer it's still useful.
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +0200373 if (channel->ch_part[PART_IN].ch_bufref.br_buf != NULL)
Bram Moolenaar5d96e3a2016-05-08 21:47:01 +0200374 return TRUE;
375
Bram Moolenaarc667da52019-11-30 20:52:27 +0100376 // If there is no callback then nobody can get readahead. If the fd is
377 // closed and there is no readahead then the callback won't be called.
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100378 has_sock_msg = channel->ch_part[PART_SOCK].ch_fd != INVALID_FD
Bram Moolenaard23a8232018-02-10 18:45:26 +0100379 || channel->ch_part[PART_SOCK].ch_head.rq_next != NULL
380 || channel->ch_part[PART_SOCK].ch_json_head.jq_next != NULL;
Bram Moolenaarfdd6ce42016-02-28 22:21:38 +0100381 has_out_msg = channel->ch_part[PART_OUT].ch_fd != INVALID_FD
382 || channel->ch_part[PART_OUT].ch_head.rq_next != NULL
383 || channel->ch_part[PART_OUT].ch_json_head.jq_next != NULL;
384 has_err_msg = channel->ch_part[PART_ERR].ch_fd != INVALID_FD
385 || channel->ch_part[PART_ERR].ch_head.rq_next != NULL
386 || channel->ch_part[PART_ERR].ch_json_head.jq_next != NULL;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200387 return (channel->ch_callback.cb_name != NULL && (has_sock_msg
Bram Moolenaar509ce2a2016-03-11 22:52:15 +0100388 || has_out_msg || has_err_msg))
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200389 || ((channel->ch_part[PART_OUT].ch_callback.cb_name != NULL
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +0200390 || channel->ch_part[PART_OUT].ch_bufref.br_buf != NULL)
391 && has_out_msg)
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200392 || ((channel->ch_part[PART_ERR].ch_callback.cb_name != NULL
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +0200393 || channel->ch_part[PART_ERR].ch_bufref.br_buf != NULL)
394 && has_err_msg);
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100395}
396
397/*
Bram Moolenaar4e9d4432018-04-24 20:54:07 +0200398 * Return TRUE if "channel" is closeable (i.e. all readable fds are closed).
399 */
Bram Moolenaar8b5866d2020-09-05 15:48:51 +0200400 int
Bram Moolenaar4e9d4432018-04-24 20:54:07 +0200401channel_can_close(channel_T *channel)
402{
403 return channel->ch_to_be_closed == 0;
404}
405
406/*
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200407 * Close a channel and free all its resources.
Bram Moolenaar71658f72020-03-24 20:35:19 +0100408 * The "channel" pointer remains valid.
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200409 */
410 static void
411channel_free_contents(channel_T *channel)
412{
413 channel_close(channel, TRUE);
414 channel_clear(channel);
415 ch_log(channel, "Freeing channel");
416}
417
Bram Moolenaar71658f72020-03-24 20:35:19 +0100418/*
419 * Unlink "channel" from the list of channels and free it.
420 */
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200421 static void
422channel_free_channel(channel_T *channel)
423{
424 if (channel->ch_next != NULL)
425 channel->ch_next->ch_prev = channel->ch_prev;
426 if (channel->ch_prev == NULL)
427 first_channel = channel->ch_next;
428 else
429 channel->ch_prev->ch_next = channel->ch_next;
430 vim_free(channel);
431}
432
433 static void
434channel_free(channel_T *channel)
435{
436 if (!in_free_unref_items)
437 {
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +0200438 if (safe_to_invoke_callback == 0)
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +0200439 channel->ch_to_be_freed = TRUE;
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +0200440 else
441 {
442 channel_free_contents(channel);
443 channel_free_channel(channel);
444 }
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200445 }
446}
447
448/*
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100449 * Close a channel and free all its resources if there is no further action
Bram Moolenaar46c85432016-02-26 11:17:46 +0100450 * possible, there is no callback to be invoked or the associated job was
451 * killed.
Bram Moolenaar70765942016-02-28 19:28:59 +0100452 * Return TRUE if the channel was freed.
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100453 */
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100454 static int
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100455channel_may_free(channel_T *channel)
456{
Bram Moolenaar46c85432016-02-26 11:17:46 +0100457 if (!channel_still_useful(channel))
Bram Moolenaar70765942016-02-28 19:28:59 +0100458 {
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100459 channel_free(channel);
Bram Moolenaar70765942016-02-28 19:28:59 +0100460 return TRUE;
461 }
462 return FALSE;
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +0100463}
464
465/*
Bram Moolenaar8e2c9422016-03-12 13:43:33 +0100466 * Decrement the reference count on "channel" and maybe free it when it goes
467 * down to zero. Don't free it if there is a pending action.
468 * Returns TRUE when the channel is no longer referenced.
469 */
470 int
471channel_unref(channel_T *channel)
472{
473 if (channel != NULL && --channel->ch_refcount <= 0)
474 return channel_may_free(channel);
475 return FALSE;
476}
477
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200478 int
479free_unused_channels_contents(int copyID, int mask)
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100480{
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200481 int did_free = FALSE;
482 channel_T *ch;
483
Bram Moolenaarc667da52019-11-30 20:52:27 +0100484 // This is invoked from the garbage collector, which only runs at a safe
485 // point.
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +0200486 ++safe_to_invoke_callback;
487
Bram Moolenaaraeea7212020-04-02 18:50:46 +0200488 FOR_ALL_CHANNELS(ch)
Bram Moolenaar674127e2016-04-26 20:30:07 +0200489 if (!channel_still_useful(ch)
490 && (ch->ch_copyID & mask) != (copyID & mask))
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200491 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100492 // Free the channel and ordinary items it contains, but don't
493 // recurse into Lists, Dictionaries etc.
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200494 channel_free_contents(ch);
495 did_free = TRUE;
496 }
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +0200497
498 --safe_to_invoke_callback;
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200499 return did_free;
500}
501
502 void
503free_unused_channels(int copyID, int mask)
504{
505 channel_T *ch;
506 channel_T *ch_next;
507
508 for (ch = first_channel; ch != NULL; ch = ch_next)
509 {
510 ch_next = ch->ch_next;
Bram Moolenaar674127e2016-04-26 20:30:07 +0200511 if (!channel_still_useful(ch)
512 && (ch->ch_copyID & mask) != (copyID & mask))
Bram Moolenaarc667da52019-11-30 20:52:27 +0100513 // Free the channel struct itself.
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200514 channel_free_channel(ch);
Bram Moolenaar107e1ee2016-04-08 17:07:19 +0200515 }
Bram Moolenaare0874f82016-01-24 20:36:41 +0100516}
517
Bram Moolenaard04a0202016-01-26 23:30:18 +0100518#if defined(FEAT_GUI) || defined(PROTO)
Bram Moolenaar77073442016-02-13 23:23:53 +0100519
Bram Moolenaarea781452019-09-04 18:53:12 +0200520# if defined(FEAT_GUI_X11) || defined(FEAT_GUI_GTK)
521/*
522 * Lookup the channel from the socket. Set "partp" to the fd index.
523 * Returns NULL when the socket isn't found.
524 */
525 static channel_T *
526channel_fd2channel(sock_T fd, ch_part_T *partp)
527{
528 channel_T *channel;
529 ch_part_T part;
530
531 if (fd != INVALID_FD)
Bram Moolenaaraeea7212020-04-02 18:50:46 +0200532 FOR_ALL_CHANNELS(channel)
Bram Moolenaarea781452019-09-04 18:53:12 +0200533 {
534 for (part = PART_SOCK; part < PART_IN; ++part)
535 if (channel->ch_part[part].ch_fd == fd)
536 {
537 *partp = part;
538 return channel;
539 }
540 }
541 return NULL;
542}
543
Bram Moolenaar77073442016-02-13 23:23:53 +0100544 static void
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100545channel_read_fd(int fd)
Bram Moolenaar77073442016-02-13 23:23:53 +0100546{
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100547 channel_T *channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +0200548 ch_part_T part;
Bram Moolenaar77073442016-02-13 23:23:53 +0100549
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100550 channel = channel_fd2channel(fd, &part);
Bram Moolenaar77073442016-02-13 23:23:53 +0100551 if (channel == NULL)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200552 ch_error(NULL, "Channel for fd %d not found", fd);
Bram Moolenaar77073442016-02-13 23:23:53 +0100553 else
Bram Moolenaarf8df45d2016-05-25 21:48:13 +0200554 channel_read(channel, part, "channel_read_fd");
Bram Moolenaar77073442016-02-13 23:23:53 +0100555}
Bram Moolenaarea781452019-09-04 18:53:12 +0200556# endif
Bram Moolenaar77073442016-02-13 23:23:53 +0100557
Bram Moolenaare0874f82016-01-24 20:36:41 +0100558/*
Bram Moolenaard04a0202016-01-26 23:30:18 +0100559 * Read a command from netbeans.
Bram Moolenaare0874f82016-01-24 20:36:41 +0100560 */
Bram Moolenaarea781452019-09-04 18:53:12 +0200561# ifdef FEAT_GUI_X11
Bram Moolenaard04a0202016-01-26 23:30:18 +0100562 static void
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200563messageFromServerX11(XtPointer clientData,
Bram Moolenaarf8df45d2016-05-25 21:48:13 +0200564 int *unused1 UNUSED,
565 XtInputId *unused2 UNUSED)
Bram Moolenaare0874f82016-01-24 20:36:41 +0100566{
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100567 channel_read_fd((int)(long)clientData);
Bram Moolenaare0874f82016-01-24 20:36:41 +0100568}
Bram Moolenaarea781452019-09-04 18:53:12 +0200569# endif
Bram Moolenaare0874f82016-01-24 20:36:41 +0100570
Bram Moolenaarea781452019-09-04 18:53:12 +0200571# ifdef FEAT_GUI_GTK
572# if GTK_CHECK_VERSION(3,0,0)
Bram Moolenaar98921892016-02-23 17:14:37 +0100573 static gboolean
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200574messageFromServerGtk3(GIOChannel *unused1 UNUSED,
Bram Moolenaarf8df45d2016-05-25 21:48:13 +0200575 GIOCondition unused2 UNUSED,
576 gpointer clientData)
Bram Moolenaar98921892016-02-23 17:14:37 +0100577{
578 channel_read_fd(GPOINTER_TO_INT(clientData));
Bram Moolenaarc667da52019-11-30 20:52:27 +0100579 return TRUE; // Return FALSE instead in case the event source is to
580 // be removed after this function returns.
Bram Moolenaar98921892016-02-23 17:14:37 +0100581}
Bram Moolenaarea781452019-09-04 18:53:12 +0200582# else
Bram Moolenaard04a0202016-01-26 23:30:18 +0100583 static void
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200584messageFromServerGtk2(gpointer clientData,
Bram Moolenaarf8df45d2016-05-25 21:48:13 +0200585 gint unused1 UNUSED,
586 GdkInputCondition unused2 UNUSED)
Bram Moolenaare0874f82016-01-24 20:36:41 +0100587{
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100588 channel_read_fd((int)(long)clientData);
Bram Moolenaare0874f82016-01-24 20:36:41 +0100589}
Bram Moolenaarea781452019-09-04 18:53:12 +0200590# endif
Bram Moolenaar98921892016-02-23 17:14:37 +0100591# endif
Bram Moolenaare0874f82016-01-24 20:36:41 +0100592
593 static void
Bram Moolenaarbd67aac2019-09-21 23:09:04 +0200594channel_gui_register_one(channel_T *channel, ch_part_T part UNUSED)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100595{
Bram Moolenaarde279892016-03-11 22:19:44 +0100596 if (!CH_HAS_GUI)
597 return;
598
Bram Moolenaarc667da52019-11-30 20:52:27 +0100599 // gets stuck in handling events for a not connected channel
Bram Moolenaar13ebb032017-08-26 22:02:51 +0200600 if (channel->ch_keep_open)
601 return;
602
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100603# ifdef FEAT_GUI_X11
Bram Moolenaarc667da52019-11-30 20:52:27 +0100604 // Tell notifier we are interested in being called when there is input on
605 // the editor connection socket.
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100606 if (channel->ch_part[part].ch_inputHandler == (XtInputId)NULL)
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200607 {
608 ch_log(channel, "Registering part %s with fd %d",
609 part_names[part], channel->ch_part[part].ch_fd);
610
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100611 channel->ch_part[part].ch_inputHandler = XtAppAddInput(
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100612 (XtAppContext)app_context,
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100613 channel->ch_part[part].ch_fd,
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100614 (XtPointer)(XtInputReadMask + XtInputExceptMask),
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200615 messageFromServerX11,
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100616 (XtPointer)(long)channel->ch_part[part].ch_fd);
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200617 }
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100618# else
619# ifdef FEAT_GUI_GTK
Bram Moolenaarc667da52019-11-30 20:52:27 +0100620 // Tell gdk we are interested in being called when there is input on the
621 // editor connection socket.
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100622 if (channel->ch_part[part].ch_inputHandler == 0)
Bram Moolenaar98921892016-02-23 17:14:37 +0100623 {
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200624 ch_log(channel, "Registering part %s with fd %d",
625 part_names[part], channel->ch_part[part].ch_fd);
626# if GTK_CHECK_VERSION(3,0,0)
Bram Moolenaar98921892016-02-23 17:14:37 +0100627 GIOChannel *chnnl = g_io_channel_unix_new(
628 (gint)channel->ch_part[part].ch_fd);
629
630 channel->ch_part[part].ch_inputHandler = g_io_add_watch(
631 chnnl,
632 G_IO_IN|G_IO_HUP|G_IO_ERR|G_IO_PRI,
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200633 messageFromServerGtk3,
Bram Moolenaar98921892016-02-23 17:14:37 +0100634 GINT_TO_POINTER(channel->ch_part[part].ch_fd));
635
636 g_io_channel_unref(chnnl);
Bram Moolenaar98921892016-02-23 17:14:37 +0100637# else
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100638 channel->ch_part[part].ch_inputHandler = gdk_input_add(
639 (gint)channel->ch_part[part].ch_fd,
Bram Moolenaar16eb4f82016-02-14 23:02:34 +0100640 (GdkInputCondition)
641 ((int)GDK_INPUT_READ + (int)GDK_INPUT_EXCEPTION),
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200642 messageFromServerGtk2,
Bram Moolenaarfffd5562016-02-20 18:44:39 +0100643 (gpointer)(long)channel->ch_part[part].ch_fd);
Bram Moolenaar98921892016-02-23 17:14:37 +0100644# endif
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200645 }
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100646# endif
647# endif
648}
649
Bram Moolenaarde279892016-03-11 22:19:44 +0100650 static void
Bram Moolenaar77073442016-02-13 23:23:53 +0100651channel_gui_register(channel_T *channel)
Bram Moolenaare0874f82016-01-24 20:36:41 +0100652{
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100653 if (channel->CH_SOCK_FD != INVALID_FD)
654 channel_gui_register_one(channel, PART_SOCK);
Bram Moolenaar13ebb032017-08-26 22:02:51 +0200655 if (channel->CH_OUT_FD != INVALID_FD
656 && channel->CH_OUT_FD != channel->CH_SOCK_FD)
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100657 channel_gui_register_one(channel, PART_OUT);
Bram Moolenaar13ebb032017-08-26 22:02:51 +0200658 if (channel->CH_ERR_FD != INVALID_FD
659 && channel->CH_ERR_FD != channel->CH_SOCK_FD
660 && channel->CH_ERR_FD != channel->CH_OUT_FD)
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100661 channel_gui_register_one(channel, PART_ERR);
Bram Moolenaard04a0202016-01-26 23:30:18 +0100662}
663
664/*
665 * Register any of our file descriptors with the GUI event handling system.
666 * Called when the GUI has started.
667 */
668 void
669channel_gui_register_all(void)
670{
Bram Moolenaar77073442016-02-13 23:23:53 +0100671 channel_T *channel;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100672
Bram Moolenaaraeea7212020-04-02 18:50:46 +0200673 FOR_ALL_CHANNELS(channel)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100674 channel_gui_register(channel);
675}
676
677 static void
Bram Moolenaarbd67aac2019-09-21 23:09:04 +0200678channel_gui_unregister_one(channel_T *channel UNUSED, ch_part_T part UNUSED)
Bram Moolenaarde279892016-03-11 22:19:44 +0100679{
680# ifdef FEAT_GUI_X11
681 if (channel->ch_part[part].ch_inputHandler != (XtInputId)NULL)
682 {
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200683 ch_log(channel, "Unregistering part %s", part_names[part]);
Bram Moolenaarde279892016-03-11 22:19:44 +0100684 XtRemoveInput(channel->ch_part[part].ch_inputHandler);
685 channel->ch_part[part].ch_inputHandler = (XtInputId)NULL;
686 }
687# else
688# ifdef FEAT_GUI_GTK
689 if (channel->ch_part[part].ch_inputHandler != 0)
690 {
Bram Moolenaarb0b98d52018-05-05 21:01:00 +0200691 ch_log(channel, "Unregistering part %s", part_names[part]);
Bram Moolenaarde279892016-03-11 22:19:44 +0100692# if GTK_CHECK_VERSION(3,0,0)
693 g_source_remove(channel->ch_part[part].ch_inputHandler);
694# else
695 gdk_input_remove(channel->ch_part[part].ch_inputHandler);
696# endif
697 channel->ch_part[part].ch_inputHandler = 0;
698 }
699# endif
700# endif
701}
702
703 static void
Bram Moolenaar16eb4f82016-02-14 23:02:34 +0100704channel_gui_unregister(channel_T *channel)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +0100705{
Bram Moolenaardc0ccae2016-10-09 17:28:01 +0200706 ch_part_T part;
Bram Moolenaar16eb4f82016-02-14 23:02:34 +0100707
Bram Moolenaar42d38a22016-02-20 18:18:59 +0100708 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaarde279892016-03-11 22:19:44 +0100709 channel_gui_unregister_one(channel, part);
Bram Moolenaard04a0202016-01-26 23:30:18 +0100710}
711
Bram Moolenaarea781452019-09-04 18:53:12 +0200712#endif // FEAT_GUI
Bram Moolenaard04a0202016-01-26 23:30:18 +0100713
Bram Moolenaare74e8e72016-02-16 22:01:30 +0100714static char *e_cannot_connect = N_("E902: Cannot connect to port");
715
Bram Moolenaard04a0202016-01-26 23:30:18 +0100716/*
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200717 * For Unix we need to call connect() again after connect() failed.
718 * On Win32 one time is sufficient.
Bram Moolenaard04a0202016-01-26 23:30:18 +0100719 */
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200720 static int
721channel_connect(
722 channel_T *channel,
723 const struct sockaddr *server_addr,
724 int server_addrlen,
725 int *waittime)
Bram Moolenaard04a0202016-01-26 23:30:18 +0100726{
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200727 int sd = -1;
Bram Moolenaar4f974752019-02-17 17:44:42 +0100728#ifdef MSWIN
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200729 u_long val = 1;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100730#endif
731
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100732 while (TRUE)
733 {
Bram Moolenaar562ca712016-03-09 21:50:05 +0100734 long elapsed_msec = 0;
735 int waitnow;
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200736 int ret;
Bram Moolenaar045a2842016-03-08 22:33:07 +0100737
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100738 if (sd >= 0)
Bram Moolenaard04a0202016-01-26 23:30:18 +0100739 sock_close(sd);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200740 sd = socket(server_addr->sa_family, SOCK_STREAM, 0);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100741 if (sd == -1)
742 {
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200743 ch_error(channel, "in socket() in channel_connect().");
744 PERROR(_("E898: socket() in channel_connect()"));
745 return -1;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100746 }
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100747
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200748 if (*waittime >= 0)
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100749 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100750 // Make connect() non-blocking.
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100751 if (
Bram Moolenaar4f974752019-02-17 17:44:42 +0100752#ifdef MSWIN
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100753 ioctlsocket(sd, FIONBIO, &val) < 0
754#else
755 fcntl(sd, F_SETFL, O_NONBLOCK) < 0
756#endif
757 )
758 {
759 SOCK_ERRNO;
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200760 ch_error(channel,
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200761 "channel_connect: Connect failed with errno %d", errno);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100762 sock_close(sd);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200763 return -1;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100764 }
765 }
766
Bram Moolenaarc667da52019-11-30 20:52:27 +0100767 // Try connecting to the server.
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200768 ch_log(channel, "Connecting...");
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100769
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200770 ret = connect(sd, server_addr, server_addrlen);
Bram Moolenaar045a2842016-03-08 22:33:07 +0100771 if (ret == 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100772 // The connection could be established.
Bram Moolenaar045a2842016-03-08 22:33:07 +0100773 break;
774
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100775 SOCK_ERRNO;
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200776 if (*waittime < 0 || (errno != EWOULDBLOCK
Bram Moolenaar045a2842016-03-08 22:33:07 +0100777 && errno != ECONNREFUSED
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100778#ifdef EINPROGRESS
Bram Moolenaar045a2842016-03-08 22:33:07 +0100779 && errno != EINPROGRESS
Bram Moolenaar6463ca22016-02-13 17:04:46 +0100780#endif
Bram Moolenaar045a2842016-03-08 22:33:07 +0100781 ))
782 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200783 ch_error(channel,
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200784 "channel_connect: Connect failed with errno %d", errno);
Bram Moolenaar045a2842016-03-08 22:33:07 +0100785 PERROR(_(e_cannot_connect));
786 sock_close(sd);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200787 return -1;
788 }
789 else if (errno == ECONNREFUSED)
790 {
791 ch_error(channel, "channel_connect: Connection refused");
792 sock_close(sd);
793 return -1;
Bram Moolenaard04a0202016-01-26 23:30:18 +0100794 }
Bram Moolenaard04a0202016-01-26 23:30:18 +0100795
Bram Moolenaarc667da52019-11-30 20:52:27 +0100796 // Limit the waittime to 50 msec. If it doesn't work within this
797 // time we close the socket and try creating it again.
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200798 waitnow = *waittime > 50 ? 50 : *waittime;
Bram Moolenaar40e8cb22016-03-10 21:10:58 +0100799
Bram Moolenaarc667da52019-11-30 20:52:27 +0100800 // If connect() didn't finish then try using select() to wait for the
801 // connection to be made. For Win32 always use select() to wait.
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100802 {
803 struct timeval tv;
Bram Moolenaard42119f2016-02-28 20:51:49 +0100804 fd_set rfds;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100805 fd_set wfds;
Bram Moolenaar4f974752019-02-17 17:44:42 +0100806#ifndef MSWIN
Bram Moolenaard42119f2016-02-28 20:51:49 +0100807 int so_error = 0;
808 socklen_t so_error_len = sizeof(so_error);
Bram Moolenaar045a2842016-03-08 22:33:07 +0100809 struct timeval start_tv;
810 struct timeval end_tv;
Bram Moolenaare081e212016-02-28 22:33:46 +0100811#endif
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100812 FD_ZERO(&rfds);
813 FD_SET(sd, &rfds);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100814 FD_ZERO(&wfds);
815 FD_SET(sd, &wfds);
Bram Moolenaare74e8e72016-02-16 22:01:30 +0100816
Bram Moolenaar562ca712016-03-09 21:50:05 +0100817 tv.tv_sec = waitnow / 1000;
818 tv.tv_usec = (waitnow % 1000) * 1000;
Bram Moolenaar4f974752019-02-17 17:44:42 +0100819#ifndef MSWIN
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100820 gettimeofday(&start_tv, NULL);
821#endif
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200822 ch_log(channel,
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200823 "Waiting for connection (waiting %d msec)...", waitnow);
Bram Moolenaare74e8e72016-02-16 22:01:30 +0100824
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200825 ret = select((int)sd + 1, &rfds, &wfds, NULL, &tv);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100826 if (ret < 0)
827 {
828 SOCK_ERRNO;
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200829 ch_error(channel,
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200830 "channel_connect: Connect failed with errno %d", errno);
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100831 PERROR(_(e_cannot_connect));
832 sock_close(sd);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200833 return -1;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100834 }
Bram Moolenaard42119f2016-02-28 20:51:49 +0100835
Bram Moolenaar4f974752019-02-17 17:44:42 +0100836#ifdef MSWIN
Bram Moolenaarc667da52019-11-30 20:52:27 +0100837 // On Win32: select() is expected to work and wait for up to
838 // "waitnow" msec for the socket to be open.
Bram Moolenaar045a2842016-03-08 22:33:07 +0100839 if (FD_ISSET(sd, &wfds))
840 break;
Bram Moolenaar562ca712016-03-09 21:50:05 +0100841 elapsed_msec = waitnow;
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200842 if (*waittime > 1 && elapsed_msec < *waittime)
Bram Moolenaar562ca712016-03-09 21:50:05 +0100843 {
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200844 *waittime -= elapsed_msec;
Bram Moolenaar562ca712016-03-09 21:50:05 +0100845 continue;
846 }
Bram Moolenaare081e212016-02-28 22:33:46 +0100847#else
Bram Moolenaarc667da52019-11-30 20:52:27 +0100848 // On Linux-like systems: See socket(7) for the behavior
849 // After putting the socket in non-blocking mode, connect() will
850 // return EINPROGRESS, select() will not wait (as if writing is
851 // possible), need to use getsockopt() to check if the socket is
852 // actually able to connect.
853 // We detect a failure to connect when either read and write fds
854 // are set. Use getsockopt() to find out what kind of failure.
Bram Moolenaar42bc6dd2016-03-02 20:48:47 +0100855 if (FD_ISSET(sd, &rfds) || FD_ISSET(sd, &wfds))
Bram Moolenaard42119f2016-02-28 20:51:49 +0100856 {
857 ret = getsockopt(sd,
Bram Moolenaar045a2842016-03-08 22:33:07 +0100858 SOL_SOCKET, SO_ERROR, &so_error, &so_error_len);
Bram Moolenaard42119f2016-02-28 20:51:49 +0100859 if (ret < 0 || (so_error != 0
860 && so_error != EWOULDBLOCK
861 && so_error != ECONNREFUSED
Bram Moolenaare081e212016-02-28 22:33:46 +0100862# ifdef EINPROGRESS
Bram Moolenaard42119f2016-02-28 20:51:49 +0100863 && so_error != EINPROGRESS
Bram Moolenaare081e212016-02-28 22:33:46 +0100864# endif
Bram Moolenaard42119f2016-02-28 20:51:49 +0100865 ))
866 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +0200867 ch_error(channel,
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200868 "channel_connect: Connect failed with errno %d",
Bram Moolenaard42119f2016-02-28 20:51:49 +0100869 so_error);
870 PERROR(_(e_cannot_connect));
871 sock_close(sd);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200872 return -1;
873 }
874 else if (errno == ECONNREFUSED)
875 {
876 ch_error(channel, "channel_connect: Connection refused");
877 sock_close(sd);
878 return -1;
Bram Moolenaard42119f2016-02-28 20:51:49 +0100879 }
880 }
881
Bram Moolenaar045a2842016-03-08 22:33:07 +0100882 if (FD_ISSET(sd, &wfds) && so_error == 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100883 // Did not detect an error, connection is established.
Bram Moolenaar045a2842016-03-08 22:33:07 +0100884 break;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100885
Bram Moolenaar045a2842016-03-08 22:33:07 +0100886 gettimeofday(&end_tv, NULL);
887 elapsed_msec = (end_tv.tv_sec - start_tv.tv_sec) * 1000
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200888 + (end_tv.tv_usec - start_tv.tv_usec) / 1000;
Bram Moolenaar81661fb2016-02-18 22:23:34 +0100889#endif
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100890 }
Bram Moolenaar045a2842016-03-08 22:33:07 +0100891
Bram Moolenaar4f974752019-02-17 17:44:42 +0100892#ifndef MSWIN
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200893 if (*waittime > 1 && elapsed_msec < *waittime)
Bram Moolenaar045a2842016-03-08 22:33:07 +0100894 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100895 // The port isn't ready but we also didn't get an error.
896 // This happens when the server didn't open the socket
897 // yet. Select() may return early, wait until the remaining
898 // "waitnow" and try again.
Bram Moolenaar562ca712016-03-09 21:50:05 +0100899 waitnow -= elapsed_msec;
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200900 *waittime -= elapsed_msec;
Bram Moolenaar562ca712016-03-09 21:50:05 +0100901 if (waitnow > 0)
902 {
Bram Moolenaar0981c872020-08-23 14:28:37 +0200903 mch_delay((long)waitnow, MCH_DELAY_IGNOREINPUT);
Bram Moolenaar562ca712016-03-09 21:50:05 +0100904 ui_breakcheck();
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200905 *waittime -= waitnow;
Bram Moolenaar562ca712016-03-09 21:50:05 +0100906 }
Bram Moolenaar045a2842016-03-08 22:33:07 +0100907 if (!got_int)
908 {
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200909 if (*waittime <= 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100910 // give it one more try
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200911 *waittime = 1;
Bram Moolenaar045a2842016-03-08 22:33:07 +0100912 continue;
913 }
Bram Moolenaarc667da52019-11-30 20:52:27 +0100914 // we were interrupted, behave as if timed out
Bram Moolenaar045a2842016-03-08 22:33:07 +0100915 }
916#endif
917
Bram Moolenaarc667da52019-11-30 20:52:27 +0100918 // We timed out.
Bram Moolenaar045a2842016-03-08 22:33:07 +0100919 ch_error(channel, "Connection timed out");
920 sock_close(sd);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200921 return -1;
Bram Moolenaar7a84dbe2016-02-07 21:29:00 +0100922 }
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100923
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200924 if (*waittime >= 0)
Bram Moolenaar7a84dbe2016-02-07 21:29:00 +0100925 {
Bram Moolenaar4f974752019-02-17 17:44:42 +0100926#ifdef MSWIN
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100927 val = 0;
928 ioctlsocket(sd, FIONBIO, &val);
929#else
Bram Moolenaarfbc4b4d2016-02-07 15:14:01 +0100930 (void)fcntl(sd, F_SETFL, 0);
Bram Moolenaar4d919d72016-02-05 22:36:41 +0100931#endif
932 }
933
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200934 return sd;
935}
936
937/*
938 * Open a socket channel to "hostname":"port".
939 * "waittime" is the time in msec to wait for the connection.
940 * When negative wait forever.
941 * Returns the channel for success.
942 * Returns NULL for failure.
943 */
944 channel_T *
945channel_open(
946 const char *hostname,
947 int port,
948 int waittime,
949 void (*nb_close_cb)(void))
950{
951 int sd = -1;
952 channel_T *channel = NULL;
953#ifdef FEAT_IPV6
Bram Moolenaara38b2b72020-05-03 17:03:29 +0200954 int err;
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200955 struct addrinfo hints;
956 struct addrinfo *res = NULL;
957 struct addrinfo *addr = NULL;
958#else
959 struct sockaddr_in server;
960 struct hostent *host = NULL;
961#endif
962
963#ifdef MSWIN
964 channel_init_winsock();
965#endif
966
967 channel = add_channel();
968 if (channel == NULL)
969 {
970 ch_error(NULL, "Cannot allocate channel.");
971 return NULL;
972 }
973
974 // Get the server internet address and put into addr structure fill in the
975 // socket address structure and connect to server.
976#ifdef FEAT_IPV6
Bram Moolenaara80faa82020-04-12 19:37:17 +0200977 CLEAR_FIELD(hints);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200978 hints.ai_family = AF_UNSPEC;
979 hints.ai_socktype = SOCK_STREAM;
Bram Moolenaarc6a67c92020-09-11 19:28:19 +0200980# if defined(AI_ADDRCONFIG) && defined(AI_V4MAPPED)
981 hints.ai_flags = AI_ADDRCONFIG | AI_V4MAPPED;
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200982# endif
983 // Set port number manually in order to prevent name resolution services
984 // from being invoked in the environment where AI_NUMERICSERV is not
985 // defined.
Bram Moolenaara38b2b72020-05-03 17:03:29 +0200986 if ((err = getaddrinfo(hostname, NULL, &hints, &res)) != 0)
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200987 {
988 ch_error(channel, "in getaddrinfo() in channel_open()");
Bram Moolenaara38b2b72020-05-03 17:03:29 +0200989 semsg(_("E901: getaddrinfo() in channel_open(): %s"),
990 gai_strerror(err));
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +0200991 channel_free(channel);
992 return NULL;
993 }
994
995 for (addr = res; addr != NULL; addr = addr->ai_next)
996 {
Bram Moolenaarb6fb0512020-04-18 18:24:18 +0200997 const char *dst = hostname;
Bram Moolenaarb6fb0512020-04-18 18:24:18 +0200998# ifdef HAVE_INET_NTOP
Bram Moolenaarb60db8b2020-05-29 21:38:42 +0200999 const void *src = NULL;
Bram Moolenaarb6fb0512020-04-18 18:24:18 +02001000 char buf[NUMBUFLEN];
Bram Moolenaar208534d2020-05-30 13:07:39 +02001001# endif
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001002
1003 if (addr->ai_family == AF_INET6)
1004 {
1005 struct sockaddr_in6 *sai = (struct sockaddr_in6 *)addr->ai_addr;
1006
1007 sai->sin6_port = htons(port);
Bram Moolenaar208534d2020-05-30 13:07:39 +02001008# ifdef HAVE_INET_NTOP
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001009 src = &sai->sin6_addr;
Bram Moolenaar208534d2020-05-30 13:07:39 +02001010# endif
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001011 }
1012 else if (addr->ai_family == AF_INET)
1013 {
1014 struct sockaddr_in *sai = (struct sockaddr_in *)addr->ai_addr;
1015
1016 sai->sin_port = htons(port);
Bram Moolenaar208534d2020-05-30 13:07:39 +02001017# ifdef HAVE_INET_NTOP
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001018 src = &sai->sin_addr;
Bram Moolenaar208534d2020-05-30 13:07:39 +02001019#endif
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001020 }
Bram Moolenaar208534d2020-05-30 13:07:39 +02001021# ifdef HAVE_INET_NTOP
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001022 if (src != NULL)
1023 {
1024 dst = inet_ntop(addr->ai_family, src, buf, sizeof(buf));
Bram Moolenaarb6fb0512020-04-18 18:24:18 +02001025 if (dst == NULL)
1026 dst = hostname;
1027 else if (STRCMP(hostname, dst) != 0)
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001028 ch_log(channel, "Resolved %s to %s", hostname, dst);
1029 }
Bram Moolenaarb6fb0512020-04-18 18:24:18 +02001030# endif
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001031
1032 ch_log(channel, "Trying to connect to %s port %d", dst, port);
1033
1034 // On Mac and Solaris a zero timeout almost never works. At least wait
1035 // one millisecond. Let's do it for all systems, because we don't know
1036 // why this is needed.
1037 if (waittime == 0)
1038 waittime = 1;
1039
Bram Moolenaarea554ca2020-05-07 17:46:59 +02001040 sd = channel_connect(channel, addr->ai_addr, (int)addr->ai_addrlen,
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001041 &waittime);
1042 if (sd >= 0)
1043 break;
1044 }
1045
1046 freeaddrinfo(res);
1047#else
Bram Moolenaara80faa82020-04-12 19:37:17 +02001048 CLEAR_FIELD(server);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001049 server.sin_family = AF_INET;
1050 server.sin_port = htons(port);
1051 if ((host = gethostbyname(hostname)) == NULL)
1052 {
1053 ch_error(channel, "in gethostbyname() in channel_open()");
1054 PERROR(_("E901: gethostbyname() in channel_open()"));
1055 channel_free(channel);
1056 return NULL;
1057 }
1058 {
1059 char *p;
1060
1061 // When using host->h_addr_list[0] directly ubsan warns for it to not
1062 // be aligned. First copy the pointer to avoid that.
1063 memcpy(&p, &host->h_addr_list[0], sizeof(p));
1064 memcpy((char *)&server.sin_addr, p, host->h_length);
1065 }
1066
1067 ch_log(channel, "Trying to connect to %s port %d", hostname, port);
1068
1069 // On Mac and Solaris a zero timeout almost never works. At least wait one
1070 // millisecond. Let's do it for all systems, because we don't know why
1071 // this is needed.
1072 if (waittime == 0)
1073 waittime = 1;
1074
1075 sd = channel_connect(channel, (struct sockaddr *)&server, sizeof(server),
1076 &waittime);
1077#endif
1078
1079 if (sd < 0)
1080 {
1081 channel_free(channel);
1082 return NULL;
1083 }
1084
1085 ch_log(channel, "Connection made");
1086
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001087 channel->CH_SOCK_FD = (sock_T)sd;
Bram Moolenaar4e221c92016-02-23 13:20:22 +01001088 channel->ch_nb_close_cb = nb_close_cb;
Bram Moolenaar03602ec2016-03-20 20:57:45 +01001089 channel->ch_hostname = (char *)vim_strsave((char_u *)hostname);
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001090 channel->ch_port = port;
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02001091 channel->ch_to_be_closed |= (1U << PART_SOCK);
Bram Moolenaard04a0202016-01-26 23:30:18 +01001092
1093#ifdef FEAT_GUI
Bram Moolenaarde279892016-03-11 22:19:44 +01001094 channel_gui_register_one(channel, PART_SOCK);
Bram Moolenaard04a0202016-01-26 23:30:18 +01001095#endif
1096
Bram Moolenaar77073442016-02-13 23:23:53 +01001097 return channel;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001098}
1099
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001100 static void
1101free_set_callback(callback_T *cbp, callback_T *callback)
1102{
1103 free_callback(cbp);
1104
1105 if (callback->cb_name != NULL && *callback->cb_name != NUL)
1106 copy_callback(cbp, callback);
1107 else
1108 cbp->cb_name = NULL;
1109}
1110
1111/*
1112 * Prepare buffer "buf" for writing channel output to.
1113 */
1114 static void
1115prepare_buffer(buf_T *buf)
1116{
1117 buf_T *save_curbuf = curbuf;
1118
1119 buf_copy_options(buf, BCO_ENTER);
1120 curbuf = buf;
1121#ifdef FEAT_QUICKFIX
1122 set_option_value((char_u *)"bt", 0L, (char_u *)"nofile", OPT_LOCAL);
1123 set_option_value((char_u *)"bh", 0L, (char_u *)"hide", OPT_LOCAL);
1124#endif
1125 if (curbuf->b_ml.ml_mfp == NULL)
1126 ml_open(curbuf);
1127 curbuf = save_curbuf;
1128}
1129
1130/*
1131 * Find a buffer matching "name" or create a new one.
1132 * Returns NULL if there is something very wrong (error already reported).
1133 */
1134 static buf_T *
Bram Moolenaar261f3462019-09-07 15:45:32 +02001135channel_find_buffer(char_u *name, int err, int msg)
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001136{
1137 buf_T *buf = NULL;
1138 buf_T *save_curbuf = curbuf;
1139
1140 if (name != NULL && *name != NUL)
1141 {
1142 buf = buflist_findname(name);
1143 if (buf == NULL)
1144 buf = buflist_findname_exp(name);
1145 }
1146 if (buf == NULL)
1147 {
1148 buf = buflist_new(name == NULL || *name == NUL ? NULL : name,
1149 NULL, (linenr_T)0, BLN_LISTED | BLN_NEW);
1150 if (buf == NULL)
1151 return NULL;
1152 prepare_buffer(buf);
1153
1154 curbuf = buf;
1155 if (msg)
1156 ml_replace(1, (char_u *)(err ? "Reading from channel error..."
1157 : "Reading from channel output..."), TRUE);
1158 changed_bytes(1, 0);
1159 curbuf = save_curbuf;
1160 }
1161
1162 return buf;
1163}
1164
1165/*
1166 * Set various properties from an "opt" argument.
1167 */
1168 static void
1169channel_set_options(channel_T *channel, jobopt_T *opt)
1170{
1171 ch_part_T part;
1172
1173 if (opt->jo_set & JO_MODE)
1174 for (part = PART_SOCK; part < PART_COUNT; ++part)
1175 channel->ch_part[part].ch_mode = opt->jo_mode;
1176 if (opt->jo_set & JO_IN_MODE)
1177 channel->ch_part[PART_IN].ch_mode = opt->jo_in_mode;
1178 if (opt->jo_set & JO_OUT_MODE)
1179 channel->ch_part[PART_OUT].ch_mode = opt->jo_out_mode;
1180 if (opt->jo_set & JO_ERR_MODE)
1181 channel->ch_part[PART_ERR].ch_mode = opt->jo_err_mode;
1182 channel->ch_nonblock = opt->jo_noblock;
1183
1184 if (opt->jo_set & JO_TIMEOUT)
1185 for (part = PART_SOCK; part < PART_COUNT; ++part)
1186 channel->ch_part[part].ch_timeout = opt->jo_timeout;
1187 if (opt->jo_set & JO_OUT_TIMEOUT)
1188 channel->ch_part[PART_OUT].ch_timeout = opt->jo_out_timeout;
1189 if (opt->jo_set & JO_ERR_TIMEOUT)
1190 channel->ch_part[PART_ERR].ch_timeout = opt->jo_err_timeout;
1191 if (opt->jo_set & JO_BLOCK_WRITE)
1192 channel->ch_part[PART_IN].ch_block_write = 1;
1193
1194 if (opt->jo_set & JO_CALLBACK)
1195 free_set_callback(&channel->ch_callback, &opt->jo_callback);
1196 if (opt->jo_set & JO_OUT_CALLBACK)
1197 free_set_callback(&channel->ch_part[PART_OUT].ch_callback,
1198 &opt->jo_out_cb);
1199 if (opt->jo_set & JO_ERR_CALLBACK)
1200 free_set_callback(&channel->ch_part[PART_ERR].ch_callback,
1201 &opt->jo_err_cb);
1202 if (opt->jo_set & JO_CLOSE_CALLBACK)
1203 free_set_callback(&channel->ch_close_cb, &opt->jo_close_cb);
1204 channel->ch_drop_never = opt->jo_drop_never;
1205
1206 if ((opt->jo_set & JO_OUT_IO) && opt->jo_io[PART_OUT] == JIO_BUFFER)
1207 {
1208 buf_T *buf;
1209
Bram Moolenaarc667da52019-11-30 20:52:27 +01001210 // writing output to a buffer. Default mode is NL.
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001211 if (!(opt->jo_set & JO_OUT_MODE))
1212 channel->ch_part[PART_OUT].ch_mode = MODE_NL;
1213 if (opt->jo_set & JO_OUT_BUF)
1214 {
1215 buf = buflist_findnr(opt->jo_io_buf[PART_OUT]);
1216 if (buf == NULL)
1217 semsg(_(e_nobufnr), (long)opt->jo_io_buf[PART_OUT]);
1218 }
1219 else
1220 {
1221 int msg = TRUE;
1222
1223 if (opt->jo_set2 & JO2_OUT_MSG)
1224 msg = opt->jo_message[PART_OUT];
Bram Moolenaar261f3462019-09-07 15:45:32 +02001225 buf = channel_find_buffer(opt->jo_io_name[PART_OUT], FALSE, msg);
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001226 }
1227 if (buf != NULL)
1228 {
1229 if (opt->jo_set & JO_OUT_MODIFIABLE)
1230 channel->ch_part[PART_OUT].ch_nomodifiable =
1231 !opt->jo_modifiable[PART_OUT];
1232
1233 if (!buf->b_p_ma && !channel->ch_part[PART_OUT].ch_nomodifiable)
1234 {
Bram Moolenaar108010a2021-06-27 22:03:33 +02001235 emsg(_(e_cannot_make_changes_modifiable_is_off));
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001236 }
1237 else
1238 {
1239 ch_log(channel, "writing out to buffer '%s'",
1240 (char *)buf->b_ffname);
1241 set_bufref(&channel->ch_part[PART_OUT].ch_bufref, buf);
1242 // if the buffer was deleted or unloaded resurrect it
1243 if (buf->b_ml.ml_mfp == NULL)
1244 prepare_buffer(buf);
1245 }
1246 }
1247 }
1248
1249 if ((opt->jo_set & JO_ERR_IO) && (opt->jo_io[PART_ERR] == JIO_BUFFER
1250 || (opt->jo_io[PART_ERR] == JIO_OUT && (opt->jo_set & JO_OUT_IO)
1251 && opt->jo_io[PART_OUT] == JIO_BUFFER)))
1252 {
1253 buf_T *buf;
1254
Bram Moolenaarc667da52019-11-30 20:52:27 +01001255 // writing err to a buffer. Default mode is NL.
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001256 if (!(opt->jo_set & JO_ERR_MODE))
1257 channel->ch_part[PART_ERR].ch_mode = MODE_NL;
1258 if (opt->jo_io[PART_ERR] == JIO_OUT)
1259 buf = channel->ch_part[PART_OUT].ch_bufref.br_buf;
1260 else if (opt->jo_set & JO_ERR_BUF)
1261 {
1262 buf = buflist_findnr(opt->jo_io_buf[PART_ERR]);
1263 if (buf == NULL)
1264 semsg(_(e_nobufnr), (long)opt->jo_io_buf[PART_ERR]);
1265 }
1266 else
1267 {
1268 int msg = TRUE;
1269
1270 if (opt->jo_set2 & JO2_ERR_MSG)
1271 msg = opt->jo_message[PART_ERR];
Bram Moolenaar261f3462019-09-07 15:45:32 +02001272 buf = channel_find_buffer(opt->jo_io_name[PART_ERR], TRUE, msg);
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001273 }
1274 if (buf != NULL)
1275 {
1276 if (opt->jo_set & JO_ERR_MODIFIABLE)
1277 channel->ch_part[PART_ERR].ch_nomodifiable =
1278 !opt->jo_modifiable[PART_ERR];
1279 if (!buf->b_p_ma && !channel->ch_part[PART_ERR].ch_nomodifiable)
1280 {
Bram Moolenaar108010a2021-06-27 22:03:33 +02001281 emsg(_(e_cannot_make_changes_modifiable_is_off));
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02001282 }
1283 else
1284 {
1285 ch_log(channel, "writing err to buffer '%s'",
1286 (char *)buf->b_ffname);
1287 set_bufref(&channel->ch_part[PART_ERR].ch_bufref, buf);
1288 // if the buffer was deleted or unloaded resurrect it
1289 if (buf->b_ml.ml_mfp == NULL)
1290 prepare_buffer(buf);
1291 }
1292 }
1293 }
1294
1295 channel->ch_part[PART_OUT].ch_io = opt->jo_io[PART_OUT];
1296 channel->ch_part[PART_ERR].ch_io = opt->jo_io[PART_ERR];
1297 channel->ch_part[PART_IN].ch_io = opt->jo_io[PART_IN];
1298}
1299
1300/*
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001301 * Implements ch_open().
1302 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02001303 static channel_T *
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001304channel_open_func(typval_T *argvars)
1305{
1306 char_u *address;
1307 char_u *p;
1308 char *rest;
1309 int port;
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001310 int is_ipv6 = FALSE;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001311 jobopt_T opt;
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02001312 channel_T *channel = NULL;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001313
Bram Moolenaard155d7a2018-12-21 16:04:21 +01001314 address = tv_get_string(&argvars[0]);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001315 if (argvars[1].v_type != VAR_UNKNOWN
1316 && (argvars[1].v_type != VAR_DICT || argvars[1].vval.v_dict == NULL))
1317 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001318 emsg(_(e_invarg));
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001319 return NULL;
1320 }
1321
Bram Moolenaarc667da52019-11-30 20:52:27 +01001322 // parse address
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001323 if (*address == '[')
1324 {
1325 // ipv6 address
1326 is_ipv6 = TRUE;
1327 p = vim_strchr(address + 1, ']');
1328 if (p == NULL || *++p != ':')
1329 {
1330 semsg(_(e_invarg2), address);
1331 return NULL;
1332 }
1333 }
1334 else
1335 {
1336 p = vim_strchr(address, ':');
1337 if (p == NULL)
1338 {
1339 semsg(_(e_invarg2), address);
1340 return NULL;
1341 }
1342 }
1343 port = strtol((char *)(p + 1), &rest, 10);
1344 if (*address == NUL || port <= 0 || port >= 65536 || *rest != NUL)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001345 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001346 semsg(_(e_invarg2), address);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001347 return NULL;
1348 }
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001349 if (is_ipv6)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001350 {
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001351 // strip '[' and ']'
1352 ++address;
1353 *(p - 1) = NUL;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001354 }
Bram Moolenaarbfe13cc2020-04-12 17:53:12 +02001355 else
1356 *p = NUL;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001357
Bram Moolenaarc667da52019-11-30 20:52:27 +01001358 // parse options
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001359 clear_job_options(&opt);
1360 opt.jo_mode = MODE_JSON;
1361 opt.jo_timeout = 2000;
1362 if (get_job_options(&argvars[1], &opt,
Bram Moolenaar08d384f2017-08-11 21:51:23 +02001363 JO_MODE_ALL + JO_CB_ALL + JO_WAITTIME + JO_TIMEOUT_ALL, 0) == FAIL)
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02001364 goto theend;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001365 if (opt.jo_timeout < 0)
1366 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001367 emsg(_(e_invarg));
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02001368 goto theend;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001369 }
1370
1371 channel = channel_open((char *)address, port, opt.jo_waittime, NULL);
1372 if (channel != NULL)
1373 {
1374 opt.jo_set = JO_ALL;
1375 channel_set_options(channel, &opt);
1376 }
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02001377theend:
1378 free_job_options(&opt);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01001379 return channel;
1380}
1381
Bram Moolenaar8b5866d2020-09-05 15:48:51 +02001382 void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001383ch_close_part(channel_T *channel, ch_part_T part)
Bram Moolenaarde279892016-03-11 22:19:44 +01001384{
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001385 sock_T *fd = &channel->ch_part[part].ch_fd;
1386
Bram Moolenaarde279892016-03-11 22:19:44 +01001387 if (*fd != INVALID_FD)
1388 {
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001389 if (part == PART_SOCK)
1390 sock_close(*fd);
1391 else
Bram Moolenaar5a1feb82017-07-22 18:04:08 +02001392 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01001393 // When using a pty the same FD is set on multiple parts, only
1394 // close it when the last reference is closed.
Bram Moolenaar7c9aec42017-08-03 13:51:25 +02001395 if ((part == PART_IN || channel->CH_IN_FD != *fd)
1396 && (part == PART_OUT || channel->CH_OUT_FD != *fd)
1397 && (part == PART_ERR || channel->CH_ERR_FD != *fd))
Bram Moolenaar2dc9d262017-09-08 14:39:30 +02001398 {
Bram Moolenaar4f974752019-02-17 17:44:42 +01001399#ifdef MSWIN
Bram Moolenaar2dc9d262017-09-08 14:39:30 +02001400 if (channel->ch_named_pipe)
1401 DisconnectNamedPipe((HANDLE)fd);
1402#endif
Bram Moolenaar5a1feb82017-07-22 18:04:08 +02001403 fd_close(*fd);
Bram Moolenaar2dc9d262017-09-08 14:39:30 +02001404 }
Bram Moolenaar5a1feb82017-07-22 18:04:08 +02001405 }
Bram Moolenaarde279892016-03-11 22:19:44 +01001406 *fd = INVALID_FD;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001407
Bram Moolenaarc667da52019-11-30 20:52:27 +01001408 // channel is closed, may want to end the job if it was the last
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02001409 channel->ch_to_be_closed &= ~(1U << part);
Bram Moolenaarde279892016-03-11 22:19:44 +01001410 }
1411}
1412
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001413 void
Bram Moolenaard8070362016-02-15 21:56:54 +01001414channel_set_pipes(channel_T *channel, sock_T in, sock_T out, sock_T err)
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001415{
Bram Moolenaarde279892016-03-11 22:19:44 +01001416 if (in != INVALID_FD)
1417 {
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001418 ch_close_part(channel, PART_IN);
Bram Moolenaarde279892016-03-11 22:19:44 +01001419 channel->CH_IN_FD = in;
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02001420# if defined(UNIX)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001421 // Do not end the job when all output channels are closed, wait until
1422 // the job ended.
Bram Moolenaar1ecc5e42019-01-26 15:12:55 +01001423 if (mch_isatty(in))
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02001424 channel->ch_to_be_closed |= (1U << PART_IN);
1425# endif
Bram Moolenaarde279892016-03-11 22:19:44 +01001426 }
1427 if (out != INVALID_FD)
1428 {
1429# if defined(FEAT_GUI)
1430 channel_gui_unregister_one(channel, PART_OUT);
1431# endif
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001432 ch_close_part(channel, PART_OUT);
Bram Moolenaarde279892016-03-11 22:19:44 +01001433 channel->CH_OUT_FD = out;
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02001434 channel->ch_to_be_closed |= (1U << PART_OUT);
Bram Moolenaarde279892016-03-11 22:19:44 +01001435# if defined(FEAT_GUI)
1436 channel_gui_register_one(channel, PART_OUT);
1437# endif
1438 }
1439 if (err != INVALID_FD)
1440 {
1441# if defined(FEAT_GUI)
1442 channel_gui_unregister_one(channel, PART_ERR);
1443# endif
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001444 ch_close_part(channel, PART_ERR);
Bram Moolenaarde279892016-03-11 22:19:44 +01001445 channel->CH_ERR_FD = err;
Bram Moolenaar4e9d4432018-04-24 20:54:07 +02001446 channel->ch_to_be_closed |= (1U << PART_ERR);
Bram Moolenaarde279892016-03-11 22:19:44 +01001447# if defined(FEAT_GUI)
1448 channel_gui_register_one(channel, PART_ERR);
1449# endif
1450 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001451}
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001452
Bram Moolenaard6051b52016-02-28 15:49:03 +01001453/*
Bram Moolenaar014069a2016-03-03 22:51:40 +01001454 * Sets the job the channel is associated with and associated options.
Bram Moolenaard6051b52016-02-28 15:49:03 +01001455 * This does not keep a refcount, when the job is freed ch_job is cleared.
1456 */
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001457 void
Bram Moolenaar014069a2016-03-03 22:51:40 +01001458channel_set_job(channel_T *channel, job_T *job, jobopt_T *options)
Bram Moolenaar6463ca22016-02-13 17:04:46 +01001459{
Bram Moolenaar77073442016-02-13 23:23:53 +01001460 channel->ch_job = job;
Bram Moolenaar014069a2016-03-03 22:51:40 +01001461
1462 channel_set_options(channel, options);
1463
1464 if (job->jv_in_buf != NULL)
1465 {
1466 chanpart_T *in_part = &channel->ch_part[PART_IN];
1467
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001468 set_bufref(&in_part->ch_bufref, job->jv_in_buf);
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02001469 ch_log(channel, "reading from buffer '%s'",
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001470 (char *)in_part->ch_bufref.br_buf->b_ffname);
Bram Moolenaar014069a2016-03-03 22:51:40 +01001471 if (options->jo_set & JO_IN_TOP)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001472 {
1473 if (options->jo_in_top == 0 && !(options->jo_set & JO_IN_BOT))
1474 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01001475 // Special mode: send last-but-one line when appending a line
1476 // to the buffer.
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001477 in_part->ch_bufref.br_buf->b_write_to_channel = TRUE;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001478 in_part->ch_buf_append = TRUE;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001479 in_part->ch_buf_top =
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001480 in_part->ch_bufref.br_buf->b_ml.ml_line_count + 1;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001481 }
1482 else
1483 in_part->ch_buf_top = options->jo_in_top;
1484 }
Bram Moolenaar014069a2016-03-03 22:51:40 +01001485 else
1486 in_part->ch_buf_top = 1;
1487 if (options->jo_set & JO_IN_BOT)
1488 in_part->ch_buf_bot = options->jo_in_bot;
1489 else
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001490 in_part->ch_buf_bot = in_part->ch_bufref.br_buf->b_ml.ml_line_count;
Bram Moolenaar014069a2016-03-03 22:51:40 +01001491 }
Bram Moolenaard04a0202016-01-26 23:30:18 +01001492}
1493
1494/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001495 * Set the callback for "channel"/"part" for the response with "id".
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001496 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02001497 static void
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001498channel_set_req_callback(
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001499 channel_T *channel,
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001500 ch_part_T part,
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02001501 callback_T *callback,
Bram Moolenaar1735bc92016-03-14 23:05:14 +01001502 int id)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001503{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001504 cbq_T *head = &channel->ch_part[part].ch_cb_head;
Bram Moolenaarc799fe22019-05-28 23:08:19 +02001505 cbq_T *item = ALLOC_ONE(cbq_T);
Bram Moolenaara07fec92016-02-05 21:04:08 +01001506
1507 if (item != NULL)
1508 {
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02001509 copy_callback(&item->cq_callback, callback);
Bram Moolenaar77073442016-02-13 23:23:53 +01001510 item->cq_seq_nr = id;
1511 item->cq_prev = head->cq_prev;
1512 head->cq_prev = item;
1513 item->cq_next = NULL;
1514 if (item->cq_prev == NULL)
1515 head->cq_next = item;
1516 else
1517 item->cq_prev->cq_next = item;
Bram Moolenaara07fec92016-02-05 21:04:08 +01001518 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001519}
1520
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001521 static void
1522write_buf_line(buf_T *buf, linenr_T lnum, channel_T *channel)
1523{
1524 char_u *line = ml_get_buf(buf, lnum, FALSE);
Bram Moolenaar367aabd2016-03-08 17:13:06 +01001525 int len = (int)STRLEN(line);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001526 char_u *p;
Bram Moolenaarbf2cc5f2016-07-07 20:45:06 +02001527 int i;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001528
Bram Moolenaarc667da52019-11-30 20:52:27 +01001529 // Need to make a copy to be able to append a NL.
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001530 if ((p = alloc(len + 2)) == NULL)
1531 return;
Bram Moolenaaradb78a72016-06-27 21:10:31 +02001532 memcpy((char *)p, (char *)line, len);
Bram Moolenaarbf2cc5f2016-07-07 20:45:06 +02001533
Bram Moolenaaref68e4f2017-09-02 16:28:36 +02001534 if (channel->ch_write_text_mode)
1535 p[len] = CAR;
1536 else
1537 {
1538 for (i = 0; i < len; ++i)
1539 if (p[i] == NL)
1540 p[i] = NUL;
Bram Moolenaarbf2cc5f2016-07-07 20:45:06 +02001541
Bram Moolenaaref68e4f2017-09-02 16:28:36 +02001542 p[len] = NL;
1543 }
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001544 p[len + 1] = NUL;
Bram Moolenaar79cbdcb2016-11-11 21:14:03 +01001545 channel_send(channel, PART_IN, p, len + 1, "write_buf_line");
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001546 vim_free(p);
1547}
1548
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001549/*
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001550 * Return TRUE if "channel" can be written to.
1551 * Returns FALSE if the input is closed or the write would block.
1552 */
1553 static int
1554can_write_buf_line(channel_T *channel)
1555{
1556 chanpart_T *in_part = &channel->ch_part[PART_IN];
1557
1558 if (in_part->ch_fd == INVALID_FD)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001559 return FALSE; // pipe was closed
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001560
Bram Moolenaarc667da52019-11-30 20:52:27 +01001561 // for testing: block every other attempt to write
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001562 if (in_part->ch_block_write == 1)
1563 in_part->ch_block_write = -1;
1564 else if (in_part->ch_block_write == -1)
1565 in_part->ch_block_write = 1;
1566
Bram Moolenaarc667da52019-11-30 20:52:27 +01001567 // TODO: Win32 implementation, probably using WaitForMultipleObjects()
Bram Moolenaar4f974752019-02-17 17:44:42 +01001568#ifndef MSWIN
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001569 {
1570# if defined(HAVE_SELECT)
1571 struct timeval tval;
1572 fd_set wfds;
1573 int ret;
1574
1575 FD_ZERO(&wfds);
1576 FD_SET((int)in_part->ch_fd, &wfds);
1577 tval.tv_sec = 0;
1578 tval.tv_usec = 0;
1579 for (;;)
1580 {
1581 ret = select((int)in_part->ch_fd + 1, NULL, &wfds, NULL, &tval);
1582# ifdef EINTR
1583 SOCK_ERRNO;
1584 if (ret == -1 && errno == EINTR)
1585 continue;
1586# endif
1587 if (ret <= 0 || in_part->ch_block_write == 1)
1588 {
1589 if (ret > 0)
1590 ch_log(channel, "FAKED Input not ready for writing");
1591 else
1592 ch_log(channel, "Input not ready for writing");
1593 return FALSE;
1594 }
1595 break;
1596 }
1597# else
1598 struct pollfd fds;
1599
1600 fds.fd = in_part->ch_fd;
1601 fds.events = POLLOUT;
1602 if (poll(&fds, 1, 0) <= 0)
1603 {
1604 ch_log(channel, "Input not ready for writing");
1605 return FALSE;
1606 }
1607 if (in_part->ch_block_write == 1)
1608 {
1609 ch_log(channel, "FAKED Input not ready for writing");
1610 return FALSE;
1611 }
1612# endif
1613 }
1614#endif
1615 return TRUE;
1616}
1617
1618/*
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02001619 * Write any buffer lines to the input channel.
Bram Moolenaar014069a2016-03-03 22:51:40 +01001620 */
Bram Moolenaar8b5866d2020-09-05 15:48:51 +02001621 void
Bram Moolenaar014069a2016-03-03 22:51:40 +01001622channel_write_in(channel_T *channel)
1623{
1624 chanpart_T *in_part = &channel->ch_part[PART_IN];
1625 linenr_T lnum;
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001626 buf_T *buf = in_part->ch_bufref.br_buf;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001627 int written = 0;
Bram Moolenaar014069a2016-03-03 22:51:40 +01001628
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001629 if (buf == NULL || in_part->ch_buf_append)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001630 return; // no buffer or using appending
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001631 if (!bufref_valid(&in_part->ch_bufref) || buf->b_ml.ml_mfp == NULL)
Bram Moolenaar014069a2016-03-03 22:51:40 +01001632 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01001633 // buffer was wiped out or unloaded
Bram Moolenaarc4da1132017-07-15 19:39:43 +02001634 ch_log(channel, "input buffer has been wiped out");
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001635 in_part->ch_bufref.br_buf = NULL;
Bram Moolenaar014069a2016-03-03 22:51:40 +01001636 return;
1637 }
Bram Moolenaar014069a2016-03-03 22:51:40 +01001638
1639 for (lnum = in_part->ch_buf_top; lnum <= in_part->ch_buf_bot
1640 && lnum <= buf->b_ml.ml_line_count; ++lnum)
1641 {
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001642 if (!can_write_buf_line(channel))
1643 break;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001644 write_buf_line(buf, lnum, channel);
1645 ++written;
Bram Moolenaar014069a2016-03-03 22:51:40 +01001646 }
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001647
1648 if (written == 1)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02001649 ch_log(channel, "written line %d to channel", (int)lnum - 1);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001650 else if (written > 1)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02001651 ch_log(channel, "written %d lines to channel", written);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001652
Bram Moolenaar014069a2016-03-03 22:51:40 +01001653 in_part->ch_buf_top = lnum;
Bram Moolenaard8b55492016-09-01 14:35:22 +02001654 if (lnum > buf->b_ml.ml_line_count || lnum > in_part->ch_buf_bot)
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001655 {
Bram Moolenaardada6d22017-09-02 17:18:35 +02001656#if defined(FEAT_TERMINAL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001657 // Send CTRL-D or "eof_chars" to close stdin on MS-Windows.
Bram Moolenaar3346cc42017-09-02 14:54:21 +02001658 if (channel->ch_job != NULL)
1659 term_send_eof(channel);
1660#endif
1661
Bram Moolenaarc667da52019-11-30 20:52:27 +01001662 // Writing is done, no longer need the buffer.
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001663 in_part->ch_bufref.br_buf = NULL;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001664 ch_log(channel, "Finished writing all lines to channel");
Bram Moolenaard8b55492016-09-01 14:35:22 +02001665
Bram Moolenaarc667da52019-11-30 20:52:27 +01001666 // Close the pipe/socket, so that the other side gets EOF.
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001667 ch_close_part(channel, PART_IN);
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001668 }
1669 else
Bram Moolenaar4ac2e8d2018-04-08 12:38:26 +02001670 ch_log(channel, "Still %ld more lines to write",
1671 (long)(buf->b_ml.ml_line_count - lnum + 1));
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001672}
1673
1674/*
Bram Moolenaaraad30bb2016-06-26 17:31:03 +02001675 * Handle buffer "buf" being freed, remove it from any channels.
Bram Moolenaare0f76d02016-05-09 20:38:53 +02001676 */
1677 void
1678channel_buffer_free(buf_T *buf)
1679{
1680 channel_T *channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001681 ch_part_T part;
Bram Moolenaare0f76d02016-05-09 20:38:53 +02001682
Bram Moolenaaraeea7212020-04-02 18:50:46 +02001683 FOR_ALL_CHANNELS(channel)
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001684 for (part = PART_SOCK; part < PART_COUNT; ++part)
Bram Moolenaare0f76d02016-05-09 20:38:53 +02001685 {
1686 chanpart_T *ch_part = &channel->ch_part[part];
1687
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001688 if (ch_part->ch_bufref.br_buf == buf)
Bram Moolenaarde7eb0a2016-05-09 20:54:33 +02001689 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02001690 ch_log(channel, "%s buffer has been wiped out",
Bram Moolenaarde7eb0a2016-05-09 20:54:33 +02001691 part_names[part]);
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001692 ch_part->ch_bufref.br_buf = NULL;
Bram Moolenaarde7eb0a2016-05-09 20:54:33 +02001693 }
Bram Moolenaare0f76d02016-05-09 20:38:53 +02001694 }
1695}
1696
1697/*
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02001698 * Write any lines waiting to be written to "channel".
1699 */
1700 static void
1701channel_write_input(channel_T *channel)
1702{
1703 chanpart_T *in_part = &channel->ch_part[PART_IN];
1704
1705 if (in_part->ch_writeque.wq_next != NULL)
1706 channel_send(channel, PART_IN, (char_u *)"", 0, "channel_write_input");
1707 else if (in_part->ch_bufref.br_buf != NULL)
1708 {
1709 if (in_part->ch_buf_append)
1710 channel_write_new_lines(in_part->ch_bufref.br_buf);
1711 else
1712 channel_write_in(channel);
1713 }
1714}
1715
1716/*
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001717 * Write any lines waiting to be written to a channel.
1718 */
1719 void
Bram Moolenaarcf089462016-06-12 21:18:43 +02001720channel_write_any_lines(void)
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001721{
1722 channel_T *channel;
1723
Bram Moolenaaraeea7212020-04-02 18:50:46 +02001724 FOR_ALL_CHANNELS(channel)
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02001725 channel_write_input(channel);
Bram Moolenaar014069a2016-03-03 22:51:40 +01001726}
1727
1728/*
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001729 * Write appended lines above the last one in "buf" to the channel.
1730 */
1731 void
1732channel_write_new_lines(buf_T *buf)
1733{
1734 channel_T *channel;
1735 int found_one = FALSE;
1736
Bram Moolenaarc667da52019-11-30 20:52:27 +01001737 // There could be more than one channel for the buffer, loop over all of
1738 // them.
Bram Moolenaaraeea7212020-04-02 18:50:46 +02001739 FOR_ALL_CHANNELS(channel)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001740 {
1741 chanpart_T *in_part = &channel->ch_part[PART_IN];
1742 linenr_T lnum;
1743 int written = 0;
1744
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001745 if (in_part->ch_bufref.br_buf == buf && in_part->ch_buf_append)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001746 {
1747 if (in_part->ch_fd == INVALID_FD)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001748 continue; // pipe was closed
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001749 found_one = TRUE;
1750 for (lnum = in_part->ch_buf_bot; lnum < buf->b_ml.ml_line_count;
1751 ++lnum)
1752 {
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001753 if (!can_write_buf_line(channel))
1754 break;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001755 write_buf_line(buf, lnum, channel);
1756 ++written;
1757 }
1758
1759 if (written == 1)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02001760 ch_log(channel, "written line %d to channel", (int)lnum - 1);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001761 else if (written > 1)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02001762 ch_log(channel, "written %d lines to channel", written);
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02001763 if (lnum < buf->b_ml.ml_line_count)
Bram Moolenaar4ac2e8d2018-04-08 12:38:26 +02001764 ch_log(channel, "Still %ld more lines to write",
1765 (long)(buf->b_ml.ml_line_count - lnum));
Bram Moolenaar99ef0622016-03-06 20:22:25 +01001766
1767 in_part->ch_buf_bot = lnum;
1768 }
1769 }
1770 if (!found_one)
1771 buf->b_write_to_channel = FALSE;
1772}
1773
1774/*
Bram Moolenaar77073442016-02-13 23:23:53 +01001775 * Invoke the "callback" on channel "channel".
Bram Moolenaar7f7c3322016-04-18 19:27:24 +02001776 * This does not redraw but sets channel_need_redraw;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001777 */
1778 static void
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02001779invoke_callback(channel_T *channel, callback_T *callback, typval_T *argv)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001780{
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001781 typval_T rettv;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001782
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +02001783 if (safe_to_invoke_callback == 0)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001784 iemsg("INTERNAL: Invoking callback when it is not safe");
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +02001785
Bram Moolenaar77073442016-02-13 23:23:53 +01001786 argv[0].v_type = VAR_CHANNEL;
1787 argv[0].vval.v_channel = channel;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01001788
Bram Moolenaarc6538bc2019-08-03 18:17:11 +02001789 call_callback(callback, -1, &rettv, 2, argv);
Bram Moolenaaree1cffc2016-02-21 19:14:41 +01001790 clear_tv(&rettv);
Bram Moolenaar7f7c3322016-04-18 19:27:24 +02001791 channel_need_redraw = TRUE;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01001792}
1793
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01001794/*
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001795 * Return the first node from "channel"/"part" without removing it.
1796 * Returns NULL if there is nothing.
1797 */
1798 readq_T *
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001799channel_peek(channel_T *channel, ch_part_T part)
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001800{
1801 readq_T *head = &channel->ch_part[part].ch_head;
1802
1803 return head->rq_next;
1804}
1805
1806/*
1807 * Return a pointer to the first NL in "node".
1808 * Skips over NUL characters.
1809 * Returns NULL if there is no NL.
1810 */
1811 char_u *
1812channel_first_nl(readq_T *node)
1813{
1814 char_u *buffer = node->rq_buffer;
1815 long_u i;
1816
1817 for (i = 0; i < node->rq_buflen; ++i)
1818 if (buffer[i] == NL)
1819 return buffer + i;
1820 return NULL;
1821}
1822
1823/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001824 * Return the first buffer from channel "channel"/"part" and remove it.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001825 * The caller must free it.
1826 * Returns NULL if there is nothing.
1827 */
1828 char_u *
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001829channel_get(channel_T *channel, ch_part_T part, int *outlen)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001830{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001831 readq_T *head = &channel->ch_part[part].ch_head;
Bram Moolenaar77073442016-02-13 23:23:53 +01001832 readq_T *node = head->rq_next;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001833 char_u *p;
1834
Bram Moolenaar77073442016-02-13 23:23:53 +01001835 if (node == NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001836 return NULL;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001837 if (outlen != NULL)
1838 *outlen += node->rq_buflen;
Bram Moolenaarc667da52019-11-30 20:52:27 +01001839 // dispose of the node but keep the buffer
Bram Moolenaar77073442016-02-13 23:23:53 +01001840 p = node->rq_buffer;
1841 head->rq_next = node->rq_next;
1842 if (node->rq_next == NULL)
1843 head->rq_prev = NULL;
1844 else
1845 node->rq_next->rq_prev = NULL;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001846 vim_free(node);
1847 return p;
1848}
1849
1850/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001851 * Returns the whole buffer contents concatenated for "channel"/"part".
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001852 * Replaces NUL bytes with NL.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001853 */
1854 static char_u *
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001855channel_get_all(channel_T *channel, ch_part_T part, int *outlen)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001856{
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001857 readq_T *head = &channel->ch_part[part].ch_head;
Bram Moolenaar2c519cf2019-03-21 21:45:34 +01001858 readq_T *node;
Bram Moolenaaradb78a72016-06-27 21:10:31 +02001859 long_u len = 0;
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001860 char_u *res;
1861 char_u *p;
1862
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01001863 // Concatenate everything into one buffer.
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001864 for (node = head->rq_next; node != NULL; node = node->rq_next)
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001865 len += node->rq_buflen;
Bram Moolenaar18a4ba22019-05-24 19:39:03 +02001866 res = alloc(len + 1);
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001867 if (res == NULL)
1868 return NULL;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001869 p = res;
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001870 for (node = head->rq_next; node != NULL; node = node->rq_next)
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001871 {
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001872 mch_memmove(p, node->rq_buffer, node->rq_buflen);
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001873 p += node->rq_buflen;
1874 }
1875 *p = NUL;
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001876
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01001877 // Free all buffers
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001878 do
1879 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001880 p = channel_get(channel, part, NULL);
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001881 vim_free(p);
1882 } while (p != NULL);
1883
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001884 if (outlen != NULL)
1885 {
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01001886 // Returning the length, keep NUL characters.
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01001887 *outlen += len;
1888 return res;
1889 }
1890
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01001891 // Turn all NUL into NL, so that the result can be used as a string.
1892 p = res;
1893 while (p < res + len)
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001894 {
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01001895 if (*p == NUL)
1896 *p = NL;
Bram Moolenaar4f974752019-02-17 17:44:42 +01001897#ifdef MSWIN
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01001898 else if (*p == 0x1b)
1899 {
1900 // crush the escape sequence OSC 0/1/2: ESC ]0;
1901 if (p + 3 < res + len
1902 && p[1] == ']'
1903 && (p[2] == '0' || p[2] == '1' || p[2] == '2')
1904 && p[3] == ';')
1905 {
1906 // '\a' becomes a NL
1907 while (p < res + (len - 1) && *p != '\a')
1908 ++p;
1909 // BEL is zero width characters, suppress display mistake
1910 // ConPTY (after 10.0.18317) requires advance checking
1911 if (p[-1] == NUL)
1912 p[-1] = 0x07;
1913 }
1914 }
1915#endif
1916 ++p;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001917 }
1918
Bram Moolenaaree1f7b32016-03-28 14:42:14 +02001919 return res;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001920}
1921
1922/*
Bram Moolenaarcf089462016-06-12 21:18:43 +02001923 * Consume "len" bytes from the head of "node".
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001924 * Caller must check these bytes are available.
1925 */
1926 void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001927channel_consume(channel_T *channel, ch_part_T part, int len)
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001928{
1929 readq_T *head = &channel->ch_part[part].ch_head;
1930 readq_T *node = head->rq_next;
1931 char_u *buf = node->rq_buffer;
1932
1933 mch_memmove(buf, buf + len, node->rq_buflen - len);
1934 node->rq_buflen -= len;
Bram Moolenaar772153f2019-03-04 12:09:49 +01001935 node->rq_buffer[node->rq_buflen] = NUL;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001936}
1937
1938/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001939 * Collapses the first and second buffer for "channel"/"part".
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001940 * Returns FAIL if that is not possible.
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001941 * When "want_nl" is TRUE collapse more buffers until a NL is found.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001942 */
1943 int
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02001944channel_collapse(channel_T *channel, ch_part_T part, int want_nl)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001945{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01001946 readq_T *head = &channel->ch_part[part].ch_head;
Bram Moolenaar77073442016-02-13 23:23:53 +01001947 readq_T *node = head->rq_next;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001948 readq_T *last_node;
1949 readq_T *n;
1950 char_u *newbuf;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001951 char_u *p;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001952 long_u len;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001953
Bram Moolenaar77073442016-02-13 23:23:53 +01001954 if (node == NULL || node->rq_next == NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001955 return FAIL;
1956
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001957 last_node = node->rq_next;
Bram Moolenaar772153f2019-03-04 12:09:49 +01001958 len = node->rq_buflen + last_node->rq_buflen;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001959 if (want_nl)
1960 while (last_node->rq_next != NULL
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001961 && channel_first_nl(last_node) == NULL)
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001962 {
1963 last_node = last_node->rq_next;
1964 len += last_node->rq_buflen;
1965 }
1966
Bram Moolenaar772153f2019-03-04 12:09:49 +01001967 p = newbuf = alloc(len + 1);
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001968 if (newbuf == NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001969 return FAIL; // out of memory
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001970 mch_memmove(p, node->rq_buffer, node->rq_buflen);
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001971 p += node->rq_buflen;
Bram Moolenaar77073442016-02-13 23:23:53 +01001972 vim_free(node->rq_buffer);
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001973 node->rq_buffer = newbuf;
1974 for (n = node; n != last_node; )
1975 {
1976 n = n->rq_next;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02001977 mch_memmove(p, n->rq_buffer, n->rq_buflen);
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001978 p += n->rq_buflen;
1979 vim_free(n->rq_buffer);
1980 }
Bram Moolenaar772153f2019-03-04 12:09:49 +01001981 *p = NUL;
Bram Moolenaarbbe8d912016-06-05 16:10:57 +02001982 node->rq_buflen = (long_u)(p - newbuf);
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001983
Bram Moolenaarc667da52019-11-30 20:52:27 +01001984 // dispose of the collapsed nodes and their buffers
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02001985 for (n = node->rq_next; n != last_node; )
1986 {
1987 n = n->rq_next;
1988 vim_free(n->rq_prev);
1989 }
1990 node->rq_next = last_node->rq_next;
1991 if (last_node->rq_next == NULL)
1992 head->rq_prev = node;
1993 else
1994 last_node->rq_next->rq_prev = node;
1995 vim_free(last_node);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01001996 return OK;
1997}
1998
1999/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002000 * Store "buf[len]" on "channel"/"part".
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002001 * When "prepend" is TRUE put in front, otherwise append at the end.
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002002 * Returns OK or FAIL.
2003 */
2004 static int
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002005channel_save(channel_T *channel, ch_part_T part, char_u *buf, int len,
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002006 int prepend, char *lead)
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002007{
2008 readq_T *node;
2009 readq_T *head = &channel->ch_part[part].ch_head;
2010 char_u *p;
2011 int i;
2012
Bram Moolenaarc799fe22019-05-28 23:08:19 +02002013 node = ALLOC_ONE(readq_T);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002014 if (node == NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002015 return FAIL; // out of memory
2016 // A NUL is added at the end, because netbeans code expects that.
2017 // Otherwise a NUL may appear inside the text.
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002018 node->rq_buffer = alloc(len + 1);
2019 if (node->rq_buffer == NULL)
2020 {
2021 vim_free(node);
Bram Moolenaarc667da52019-11-30 20:52:27 +01002022 return FAIL; // out of memory
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002023 }
2024
2025 if (channel->ch_part[part].ch_mode == MODE_NL)
2026 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002027 // Drop any CR before a NL.
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002028 p = node->rq_buffer;
2029 for (i = 0; i < len; ++i)
2030 if (buf[i] != CAR || i + 1 >= len || buf[i + 1] != NL)
2031 *p++ = buf[i];
2032 *p = NUL;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02002033 node->rq_buflen = (long_u)(p - node->rq_buffer);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002034 }
2035 else
2036 {
2037 mch_memmove(node->rq_buffer, buf, len);
2038 node->rq_buffer[len] = NUL;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02002039 node->rq_buflen = (long_u)len;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002040 }
2041
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002042 if (prepend)
2043 {
Bram Moolenaarad3ec762019-04-21 00:00:13 +02002044 // prepend node to the head of the queue
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002045 node->rq_next = head->rq_next;
2046 node->rq_prev = NULL;
2047 if (head->rq_next == NULL)
2048 head->rq_prev = node;
2049 else
2050 head->rq_next->rq_prev = node;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002051 head->rq_next = node;
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002052 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002053 else
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002054 {
Bram Moolenaarad3ec762019-04-21 00:00:13 +02002055 // append node to the tail of the queue
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002056 node->rq_next = NULL;
2057 node->rq_prev = head->rq_prev;
2058 if (head->rq_prev == NULL)
2059 head->rq_next = node;
2060 else
2061 head->rq_prev->rq_next = node;
2062 head->rq_prev = node;
2063 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002064
Bram Moolenaar71eeb742017-09-13 22:18:01 +02002065 if (ch_log_active() && lead != NULL)
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002066 {
Bram Moolenaar4b16ee72018-08-09 22:15:34 +02002067 ch_log_lead(lead, channel, part);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002068 fprintf(log_fd, "'");
Bram Moolenaar42335f52018-09-13 15:33:43 +02002069 vim_ignored = (int)fwrite(buf, len, 1, log_fd);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002070 fprintf(log_fd, "'\n");
2071 }
2072 return OK;
2073}
2074
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002075/*
2076 * Try to fill the buffer of "reader".
2077 * Returns FALSE when nothing was added.
2078 */
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002079 static int
2080channel_fill(js_read_T *reader)
2081{
2082 channel_T *channel = (channel_T *)reader->js_cookie;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002083 ch_part_T part = reader->js_cookie_arg;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002084 char_u *next = channel_get(channel, part, NULL);
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002085 int keeplen;
2086 int addlen;
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002087 char_u *p;
2088
2089 if (next == NULL)
2090 return FALSE;
2091
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002092 keeplen = reader->js_end - reader->js_buf;
2093 if (keeplen > 0)
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002094 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002095 // Prepend unused text.
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002096 addlen = (int)STRLEN(next);
2097 p = alloc(keeplen + addlen + 1);
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002098 if (p == NULL)
2099 {
2100 vim_free(next);
2101 return FALSE;
2102 }
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002103 mch_memmove(p, reader->js_buf, keeplen);
2104 mch_memmove(p + keeplen, next, addlen + 1);
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002105 vim_free(next);
2106 next = p;
2107 }
2108
2109 vim_free(reader->js_buf);
2110 reader->js_buf = next;
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002111 return TRUE;
2112}
2113
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002114/*
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002115 * Use the read buffer of "channel"/"part" and parse a JSON message that is
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002116 * complete. The messages are added to the queue.
Bram Moolenaard7ece102016-02-02 23:23:02 +01002117 * Return TRUE if there is more to read.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002118 */
Bram Moolenaard7ece102016-02-02 23:23:02 +01002119 static int
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002120channel_parse_json(channel_T *channel, ch_part_T part)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002121{
2122 js_read_T reader;
2123 typval_T listtv;
2124 jsonq_T *item;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002125 chanpart_T *chanpart = &channel->ch_part[part];
2126 jsonq_T *head = &chanpart->ch_json_head;
2127 int status;
Bram Moolenaard7ece102016-02-02 23:23:02 +01002128 int ret;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002129
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002130 if (channel_peek(channel, part) == NULL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01002131 return FALSE;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002132
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002133 reader.js_buf = channel_get(channel, part, NULL);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002134 reader.js_used = 0;
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002135 reader.js_fill = channel_fill;
Bram Moolenaar77073442016-02-13 23:23:53 +01002136 reader.js_cookie = channel;
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002137 reader.js_cookie_arg = part;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002138
Bram Moolenaarc667da52019-11-30 20:52:27 +01002139 // When a message is incomplete we wait for a short while for more to
2140 // arrive. After the delay drop the input, otherwise a truncated string
2141 // or list will make us hang.
2142 // Do not generate error messages, they will be written in a channel log.
Bram Moolenaar03c60c12017-01-10 15:15:37 +01002143 ++emsg_silent;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002144 status = json_decode(&reader, &listtv,
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002145 chanpart->ch_mode == MODE_JS ? JSON_JS : 0);
Bram Moolenaar03c60c12017-01-10 15:15:37 +01002146 --emsg_silent;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002147 if (status == OK)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002148 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002149 // Only accept the response when it is a list with at least two
2150 // items.
Bram Moolenaar6076fe12016-02-05 22:49:56 +01002151 if (listtv.v_type != VAR_LIST || listtv.vval.v_list->lv_len < 2)
Bram Moolenaard7ece102016-02-02 23:23:02 +01002152 {
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002153 if (listtv.v_type != VAR_LIST)
2154 ch_error(channel, "Did not receive a list, discarding");
2155 else
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002156 ch_error(channel, "Expected list with two items, got %d",
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002157 listtv.vval.v_list->lv_len);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002158 clear_tv(&listtv);
Bram Moolenaard7ece102016-02-02 23:23:02 +01002159 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002160 else
2161 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02002162 item = ALLOC_ONE(jsonq_T);
Bram Moolenaard7ece102016-02-02 23:23:02 +01002163 if (item == NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002164 clear_tv(&listtv);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002165 else
2166 {
Bram Moolenaar958dc692016-12-01 15:34:12 +01002167 item->jq_no_callback = FALSE;
Bram Moolenaar77073442016-02-13 23:23:53 +01002168 item->jq_value = alloc_tv();
2169 if (item->jq_value == NULL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01002170 {
2171 vim_free(item);
2172 clear_tv(&listtv);
2173 }
2174 else
2175 {
Bram Moolenaar77073442016-02-13 23:23:53 +01002176 *item->jq_value = listtv;
2177 item->jq_prev = head->jq_prev;
2178 head->jq_prev = item;
2179 item->jq_next = NULL;
2180 if (item->jq_prev == NULL)
2181 head->jq_next = item;
2182 else
2183 item->jq_prev->jq_next = item;
Bram Moolenaard7ece102016-02-02 23:23:02 +01002184 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002185 }
2186 }
2187 }
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002188
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002189 if (status == OK)
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002190 chanpart->ch_wait_len = 0;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002191 else if (status == MAYBE)
Bram Moolenaard7ece102016-02-02 23:23:02 +01002192 {
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002193 size_t buflen = STRLEN(reader.js_buf);
2194
2195 if (chanpart->ch_wait_len < buflen)
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002196 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002197 // First time encountering incomplete message or after receiving
2198 // more (but still incomplete): set a deadline of 100 msec.
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002199 ch_log(channel,
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002200 "Incomplete message (%d bytes) - wait 100 msec for more",
Bram Moolenaarb113c3a2017-02-28 21:26:17 +01002201 (int)buflen);
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002202 reader.js_used = 0;
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002203 chanpart->ch_wait_len = buflen;
Bram Moolenaar4f974752019-02-17 17:44:42 +01002204#ifdef MSWIN
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002205 chanpart->ch_deadline = GetTickCount() + 100L;
2206#else
2207 gettimeofday(&chanpart->ch_deadline, NULL);
2208 chanpart->ch_deadline.tv_usec += 100 * 1000;
2209 if (chanpart->ch_deadline.tv_usec > 1000 * 1000)
2210 {
2211 chanpart->ch_deadline.tv_usec -= 1000 * 1000;
2212 ++chanpart->ch_deadline.tv_sec;
2213 }
2214#endif
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002215 }
2216 else
2217 {
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002218 int timeout;
Bram Moolenaar4f974752019-02-17 17:44:42 +01002219#ifdef MSWIN
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002220 timeout = GetTickCount() > chanpart->ch_deadline;
2221#else
2222 {
2223 struct timeval now_tv;
2224
2225 gettimeofday(&now_tv, NULL);
2226 timeout = now_tv.tv_sec > chanpart->ch_deadline.tv_sec
2227 || (now_tv.tv_sec == chanpart->ch_deadline.tv_sec
2228 && now_tv.tv_usec > chanpart->ch_deadline.tv_usec);
2229 }
2230#endif
2231 if (timeout)
2232 {
2233 status = FAIL;
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002234 chanpart->ch_wait_len = 0;
2235 ch_log(channel, "timed out");
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002236 }
2237 else
2238 {
2239 reader.js_used = 0;
2240 ch_log(channel, "still waiting on incomplete message");
2241 }
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002242 }
Bram Moolenaard7ece102016-02-02 23:23:02 +01002243 }
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002244
2245 if (status == FAIL)
2246 {
2247 ch_error(channel, "Decoding failed - discarding input");
2248 ret = FALSE;
Bram Moolenaar88989cc2017-02-06 21:56:09 +01002249 chanpart->ch_wait_len = 0;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002250 }
2251 else if (reader.js_buf[reader.js_used] != NUL)
2252 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002253 // Put the unread part back into the channel.
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002254 channel_save(channel, part, reader.js_buf + reader.js_used,
Bram Moolenaar46c00a62016-03-28 14:11:42 +02002255 (int)(reader.js_end - reader.js_buf) - reader.js_used,
2256 TRUE, NULL);
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002257 ret = status == MAYBE ? FALSE: TRUE;
2258 }
Bram Moolenaard7ece102016-02-02 23:23:02 +01002259 else
2260 ret = FALSE;
2261
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002262 vim_free(reader.js_buf);
Bram Moolenaard7ece102016-02-02 23:23:02 +01002263 return ret;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002264}
2265
2266/*
Bram Moolenaard46ae142016-02-16 13:33:52 +01002267 * Remove "node" from the queue that it is in. Does not free it.
Bram Moolenaara07fec92016-02-05 21:04:08 +01002268 */
2269 static void
Bram Moolenaar77073442016-02-13 23:23:53 +01002270remove_cb_node(cbq_T *head, cbq_T *node)
Bram Moolenaara07fec92016-02-05 21:04:08 +01002271{
Bram Moolenaar77073442016-02-13 23:23:53 +01002272 if (node->cq_prev == NULL)
2273 head->cq_next = node->cq_next;
2274 else
2275 node->cq_prev->cq_next = node->cq_next;
2276 if (node->cq_next == NULL)
2277 head->cq_prev = node->cq_prev;
2278 else
2279 node->cq_next->cq_prev = node->cq_prev;
Bram Moolenaara07fec92016-02-05 21:04:08 +01002280}
2281
2282/*
2283 * Remove "node" from the queue that it is in and free it.
Bram Moolenaar77073442016-02-13 23:23:53 +01002284 * Caller should have freed or used node->jq_value.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002285 */
2286 static void
Bram Moolenaar77073442016-02-13 23:23:53 +01002287remove_json_node(jsonq_T *head, jsonq_T *node)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002288{
Bram Moolenaar77073442016-02-13 23:23:53 +01002289 if (node->jq_prev == NULL)
2290 head->jq_next = node->jq_next;
2291 else
2292 node->jq_prev->jq_next = node->jq_next;
2293 if (node->jq_next == NULL)
2294 head->jq_prev = node->jq_prev;
2295 else
2296 node->jq_next->jq_prev = node->jq_prev;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002297 vim_free(node);
2298}
2299
2300/*
Bram Moolenaar38ea7842019-06-09 19:51:58 +02002301 * Add "id" to the list of JSON message IDs we are waiting on.
2302 */
2303 static void
2304channel_add_block_id(chanpart_T *chanpart, int id)
2305{
2306 garray_T *gap = &chanpart->ch_block_ids;
2307
2308 if (gap->ga_growsize == 0)
2309 ga_init2(gap, (int)sizeof(int), 10);
2310 if (ga_grow(gap, 1) == OK)
2311 {
2312 ((int *)gap->ga_data)[gap->ga_len] = id;
2313 ++gap->ga_len;
2314 }
2315}
2316
2317/*
2318 * Remove "id" from the list of JSON message IDs we are waiting on.
2319 */
2320 static void
2321channel_remove_block_id(chanpart_T *chanpart, int id)
2322{
2323 garray_T *gap = &chanpart->ch_block_ids;
2324 int i;
2325
2326 for (i = 0; i < gap->ga_len; ++i)
2327 if (((int *)gap->ga_data)[i] == id)
2328 {
2329 --gap->ga_len;
2330 if (i < gap->ga_len)
2331 {
2332 int *p = ((int *)gap->ga_data) + i;
2333
2334 mch_memmove(p, p + 1, (gap->ga_len - i) * sizeof(int));
2335 }
2336 return;
2337 }
2338 siemsg("INTERNAL: channel_remove_block_id: cannot find id %d", id);
2339}
2340
2341/*
2342 * Return TRUE if "id" is in the list of JSON message IDs we are waiting on.
2343 */
2344 static int
2345channel_has_block_id(chanpart_T *chanpart, int id)
2346{
2347 garray_T *gap = &chanpart->ch_block_ids;
2348 int i;
2349
2350 for (i = 0; i < gap->ga_len; ++i)
2351 if (((int *)gap->ga_data)[i] == id)
2352 return TRUE;
2353 return FALSE;
2354}
2355
2356/*
Bram Moolenaar77073442016-02-13 23:23:53 +01002357 * Get a message from the JSON queue for channel "channel".
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002358 * When "id" is positive it must match the first number in the list.
Bram Moolenaar38ea7842019-06-09 19:51:58 +02002359 * When "id" is zero or negative jut get the first message. But not one
2360 * in the ch_block_ids list.
Bram Moolenaar958dc692016-12-01 15:34:12 +01002361 * When "without_callback" is TRUE also get messages that were pushed back.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002362 * Return OK when found and return the value in "rettv".
2363 * Return FAIL otherwise.
2364 */
2365 static int
Bram Moolenaar958dc692016-12-01 15:34:12 +01002366channel_get_json(
2367 channel_T *channel,
2368 ch_part_T part,
2369 int id,
2370 int without_callback,
2371 typval_T **rettv)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002372{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002373 jsonq_T *head = &channel->ch_part[part].ch_json_head;
Bram Moolenaar77073442016-02-13 23:23:53 +01002374 jsonq_T *item = head->jq_next;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002375
Bram Moolenaar77073442016-02-13 23:23:53 +01002376 while (item != NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002377 {
Bram Moolenaar77073442016-02-13 23:23:53 +01002378 list_T *l = item->jq_value->vval.v_list;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002379 typval_T *tv;
2380
Bram Moolenaar7e9f3512020-05-13 22:44:22 +02002381 CHECK_LIST_MATERIALIZE(l);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002382 tv = &l->lv_first->li_tv;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002383
Bram Moolenaar958dc692016-12-01 15:34:12 +01002384 if ((without_callback || !item->jq_no_callback)
2385 && ((id > 0 && tv->v_type == VAR_NUMBER && tv->vval.v_number == id)
Bram Moolenaare56bf152016-02-08 23:23:42 +01002386 || (id <= 0 && (tv->v_type != VAR_NUMBER
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002387 || tv->vval.v_number == 0
Bram Moolenaar38ea7842019-06-09 19:51:58 +02002388 || !channel_has_block_id(
2389 &channel->ch_part[part], tv->vval.v_number)))))
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002390 {
Bram Moolenaar77073442016-02-13 23:23:53 +01002391 *rettv = item->jq_value;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01002392 if (tv->v_type == VAR_NUMBER)
Bram Moolenaar4ac2e8d2018-04-08 12:38:26 +02002393 ch_log(channel, "Getting JSON message %ld",
2394 (long)tv->vval.v_number);
Bram Moolenaar77073442016-02-13 23:23:53 +01002395 remove_json_node(head, item);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002396 return OK;
2397 }
Bram Moolenaar77073442016-02-13 23:23:53 +01002398 item = item->jq_next;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002399 }
2400 return FAIL;
2401}
2402
Bram Moolenaar958dc692016-12-01 15:34:12 +01002403/*
2404 * Put back "rettv" into the JSON queue, there was no callback for it.
2405 * Takes over the values in "rettv".
2406 */
2407 static void
2408channel_push_json(channel_T *channel, ch_part_T part, typval_T *rettv)
2409{
2410 jsonq_T *head = &channel->ch_part[part].ch_json_head;
2411 jsonq_T *item = head->jq_next;
2412 jsonq_T *newitem;
2413
2414 if (head->jq_prev != NULL && head->jq_prev->jq_no_callback)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002415 // last item was pushed back, append to the end
Bram Moolenaar958dc692016-12-01 15:34:12 +01002416 item = NULL;
2417 else while (item != NULL && item->jq_no_callback)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002418 // append after the last item that was pushed back
Bram Moolenaar958dc692016-12-01 15:34:12 +01002419 item = item->jq_next;
2420
Bram Moolenaarc799fe22019-05-28 23:08:19 +02002421 newitem = ALLOC_ONE(jsonq_T);
Bram Moolenaar958dc692016-12-01 15:34:12 +01002422 if (newitem == NULL)
2423 clear_tv(rettv);
2424 else
2425 {
2426 newitem->jq_value = alloc_tv();
2427 if (newitem->jq_value == NULL)
2428 {
2429 vim_free(newitem);
2430 clear_tv(rettv);
2431 }
2432 else
2433 {
2434 newitem->jq_no_callback = FALSE;
2435 *newitem->jq_value = *rettv;
2436 if (item == NULL)
2437 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002438 // append to the end
Bram Moolenaar958dc692016-12-01 15:34:12 +01002439 newitem->jq_prev = head->jq_prev;
2440 head->jq_prev = newitem;
2441 newitem->jq_next = NULL;
2442 if (newitem->jq_prev == NULL)
2443 head->jq_next = newitem;
2444 else
2445 newitem->jq_prev->jq_next = newitem;
2446 }
2447 else
2448 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002449 // append after "item"
Bram Moolenaar958dc692016-12-01 15:34:12 +01002450 newitem->jq_prev = item;
2451 newitem->jq_next = item->jq_next;
2452 item->jq_next = newitem;
2453 if (newitem->jq_next == NULL)
2454 head->jq_prev = newitem;
2455 else
2456 newitem->jq_next->jq_prev = newitem;
2457 }
2458 }
2459 }
2460}
2461
Bram Moolenaarece61b02016-02-20 21:39:05 +01002462#define CH_JSON_MAX_ARGS 4
2463
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002464/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002465 * Execute a command received over "channel"/"part"
Bram Moolenaarece61b02016-02-20 21:39:05 +01002466 * "argv[0]" is the command string.
2467 * "argv[1]" etc. have further arguments, type is VAR_UNKNOWN if missing.
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002468 */
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002469 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002470channel_exe_cmd(channel_T *channel, ch_part_T part, typval_T *argv)
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002471{
Bram Moolenaarece61b02016-02-20 21:39:05 +01002472 char_u *cmd = argv[0].vval.v_string;
2473 char_u *arg;
2474 int options = channel->ch_part[part].ch_mode == MODE_JS ? JSON_JS : 0;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002475
Bram Moolenaarece61b02016-02-20 21:39:05 +01002476 if (argv[1].v_type != VAR_STRING)
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002477 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01002478 ch_error(channel, "received command with non-string argument");
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002479 if (p_verbose > 2)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002480 emsg(_("E903: received command with non-string argument"));
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002481 return;
2482 }
Bram Moolenaarece61b02016-02-20 21:39:05 +01002483 arg = argv[1].vval.v_string;
Bram Moolenaar14ad6112016-02-01 21:47:13 +01002484 if (arg == NULL)
2485 arg = (char_u *)"";
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002486
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002487 if (STRCMP(cmd, "ex") == 0)
2488 {
Bram Moolenaar53989552019-12-23 22:59:18 +01002489 int called_emsg_before = called_emsg;
Bram Moolenaarc4dcd602016-03-26 22:56:46 +01002490
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002491 ch_log(channel, "Executing ex command '%s'", (char *)arg);
Bram Moolenaarc4dcd602016-03-26 22:56:46 +01002492 ++emsg_silent;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002493 do_cmdline_cmd(arg);
Bram Moolenaarc4dcd602016-03-26 22:56:46 +01002494 --emsg_silent;
Bram Moolenaar53989552019-12-23 22:59:18 +01002495 if (called_emsg > called_emsg_before)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002496 ch_log(channel, "Ex command error: '%s'",
Bram Moolenaarc4dcd602016-03-26 22:56:46 +01002497 (char *)get_vim_var_str(VV_ERRMSG));
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002498 }
2499 else if (STRCMP(cmd, "normal") == 0)
2500 {
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002501 exarg_T ea;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002502
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002503 ch_log(channel, "Executing normal command '%s'", (char *)arg);
Bram Moolenaara80faa82020-04-12 19:37:17 +02002504 CLEAR_FIELD(ea);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002505 ea.arg = arg;
2506 ea.addr_count = 0;
Bram Moolenaarc667da52019-11-30 20:52:27 +01002507 ea.forceit = TRUE; // no mapping
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002508 ex_normal(&ea);
2509 }
2510 else if (STRCMP(cmd, "redraw") == 0)
2511 {
2512 exarg_T ea;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002513
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002514 ch_log(channel, "redraw");
Bram Moolenaara80faa82020-04-12 19:37:17 +02002515 CLEAR_FIELD(ea);
Bram Moolenaar14ad6112016-02-01 21:47:13 +01002516 ea.forceit = *arg != NUL;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002517 ex_redraw(&ea);
2518 showruler(FALSE);
2519 setcursor();
Bram Moolenaara338adc2018-01-31 20:51:47 +01002520 out_flush_cursor(TRUE, FALSE);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002521 }
Bram Moolenaarece61b02016-02-20 21:39:05 +01002522 else if (STRCMP(cmd, "expr") == 0 || STRCMP(cmd, "call") == 0)
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002523 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01002524 int is_call = cmd[0] == 'c';
2525 int id_idx = is_call ? 3 : 2;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002526
Bram Moolenaarece61b02016-02-20 21:39:05 +01002527 if (argv[id_idx].v_type != VAR_UNKNOWN
2528 && argv[id_idx].v_type != VAR_NUMBER)
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002529 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01002530 ch_error(channel, "last argument for expr/call must be a number");
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002531 if (p_verbose > 2)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002532 emsg(_("E904: last argument for expr/call must be a number"));
Bram Moolenaarece61b02016-02-20 21:39:05 +01002533 }
2534 else if (is_call && argv[2].v_type != VAR_LIST)
2535 {
2536 ch_error(channel, "third argument for call must be a list");
2537 if (p_verbose > 2)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002538 emsg(_("E904: third argument for call must be a list"));
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002539 }
2540 else
2541 {
Bram Moolenaarc8fe3382016-09-04 20:44:42 +02002542 typval_T *tv = NULL;
Bram Moolenaarece61b02016-02-20 21:39:05 +01002543 typval_T res_tv;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002544 typval_T err_tv;
Bram Moolenaar55fab432016-02-07 16:53:13 +01002545 char_u *json = NULL;
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002546
Bram Moolenaarc667da52019-11-30 20:52:27 +01002547 // Don't pollute the display with errors.
Alisue11a632d2021-06-30 22:01:02 +02002548 // Do generate the errors so that try/catch works.
2549 ++emsg_silent;
Bram Moolenaarece61b02016-02-20 21:39:05 +01002550 if (!is_call)
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002551 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002552 ch_log(channel, "Evaluating expression '%s'", (char *)arg);
Bram Moolenaarece61b02016-02-20 21:39:05 +01002553 tv = eval_expr(arg, NULL);
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002554 }
Bram Moolenaarece61b02016-02-20 21:39:05 +01002555 else
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002556 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002557 ch_log(channel, "Calling '%s'", (char *)arg);
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002558 if (func_call(arg, &argv[2], NULL, NULL, &res_tv) == OK)
2559 tv = &res_tv;
Bram Moolenaarac74d5e2016-03-20 14:31:00 +01002560 }
Bram Moolenaarece61b02016-02-20 21:39:05 +01002561
2562 if (argv[id_idx].v_type == VAR_NUMBER)
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002563 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01002564 int id = argv[id_idx].vval.v_number;
2565
Bram Moolenaar55fab432016-02-07 16:53:13 +01002566 if (tv != NULL)
Bram Moolenaarf1f07922016-08-26 17:58:53 +02002567 json = json_encode_nr_expr(id, tv, options | JSON_NL);
Bram Moolenaar55fab432016-02-07 16:53:13 +01002568 if (tv == NULL || (json != NULL && *json == NUL))
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002569 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002570 // If evaluation failed or the result can't be encoded
2571 // then return the string "ERROR".
Bram Moolenaar77073442016-02-13 23:23:53 +01002572 vim_free(json);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002573 err_tv.v_type = VAR_STRING;
2574 err_tv.vval.v_string = (char_u *)"ERROR";
Bram Moolenaarc8fe3382016-09-04 20:44:42 +02002575 json = json_encode_nr_expr(id, &err_tv, options | JSON_NL);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002576 }
Bram Moolenaar55fab432016-02-07 16:53:13 +01002577 if (json != NULL)
2578 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01002579 channel_send(channel,
2580 part == PART_SOCK ? PART_SOCK : PART_IN,
Bram Moolenaarbf2cc5f2016-07-07 20:45:06 +02002581 json, (int)STRLEN(json), (char *)cmd);
Bram Moolenaar55fab432016-02-07 16:53:13 +01002582 vim_free(json);
2583 }
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002584 }
Alisue11a632d2021-06-30 22:01:02 +02002585 --emsg_silent;
Bram Moolenaarece61b02016-02-20 21:39:05 +01002586 if (tv == &res_tv)
2587 clear_tv(tv);
Bram Moolenaarc8fe3382016-09-04 20:44:42 +02002588 else
Bram Moolenaarfcb1e3d2016-02-03 21:32:46 +01002589 free_tv(tv);
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01002590 }
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002591 }
2592 else if (p_verbose > 2)
Bram Moolenaarece61b02016-02-20 21:39:05 +01002593 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002594 ch_error(channel, "Received unknown command: %s", (char *)cmd);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002595 semsg(_("E905: received unknown command: %s"), cmd);
Bram Moolenaarece61b02016-02-20 21:39:05 +01002596 }
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002597}
2598
Bram Moolenaar7f7c3322016-04-18 19:27:24 +02002599/*
2600 * Invoke the callback at "cbhead".
2601 * Does not redraw but sets channel_need_redraw.
2602 */
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002603 static void
2604invoke_one_time_callback(
2605 channel_T *channel,
2606 cbq_T *cbhead,
2607 cbq_T *item,
2608 typval_T *argv)
2609{
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002610 ch_log(channel, "Invoking one-time callback %s",
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02002611 (char *)item->cq_callback.cb_name);
Bram Moolenaarc667da52019-11-30 20:52:27 +01002612 // Remove the item from the list first, if the callback
2613 // invokes ch_close() the list will be cleared.
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002614 remove_cb_node(cbhead, item);
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02002615 invoke_callback(channel, &item->cq_callback, argv);
2616 free_callback(&item->cq_callback);
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002617 vim_free(item);
2618}
2619
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002620 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002621append_to_buffer(buf_T *buffer, char_u *msg, channel_T *channel, ch_part_T part)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002622{
Bram Moolenaarad9ec5e2020-09-10 21:25:45 +02002623 aco_save_T aco;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002624 linenr_T lnum = buffer->b_ml.ml_line_count;
2625 int save_write_to = buffer->b_write_to_channel;
Bram Moolenaar9f5842e2016-05-29 16:17:08 +02002626 chanpart_T *ch_part = &channel->ch_part[part];
2627 int save_p_ma = buffer->b_p_ma;
Bram Moolenaarc4da1132017-07-15 19:39:43 +02002628 int empty = (buffer->b_ml.ml_flags & ML_EMPTY) ? 1 : 0;
Bram Moolenaar9f5842e2016-05-29 16:17:08 +02002629
2630 if (!buffer->b_p_ma && !ch_part->ch_nomodifiable)
2631 {
2632 if (!ch_part->ch_nomod_error)
2633 {
2634 ch_error(channel, "Buffer is not modifiable, cannot append");
2635 ch_part->ch_nomod_error = TRUE;
2636 }
2637 return;
2638 }
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002639
Bram Moolenaarc667da52019-11-30 20:52:27 +01002640 // If the buffer is also used as input insert above the last
2641 // line. Don't write these lines.
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002642 if (save_write_to)
2643 {
2644 --lnum;
2645 buffer->b_write_to_channel = FALSE;
2646 }
2647
Bram Moolenaarc667da52019-11-30 20:52:27 +01002648 // Append to the buffer
Bram Moolenaarad9ec5e2020-09-10 21:25:45 +02002649 ch_log(channel, "appending line %d to buffer %s",
2650 (int)lnum + 1 - empty, buffer->b_fname);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002651
Bram Moolenaar9f5842e2016-05-29 16:17:08 +02002652 buffer->b_p_ma = TRUE;
Bram Moolenaar6b7355a2017-08-04 21:37:54 +02002653
Bram Moolenaarad9ec5e2020-09-10 21:25:45 +02002654 // set curbuf to be our buf, temporarily
2655 aucmd_prepbuf(&aco, buffer);
Bram Moolenaar6b7355a2017-08-04 21:37:54 +02002656
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002657 u_sync(TRUE);
Bram Moolenaarc667da52019-11-30 20:52:27 +01002658 // ignore undo failure, undo is not very useful here
Bram Moolenaar42335f52018-09-13 15:33:43 +02002659 vim_ignored = u_save(lnum - empty, lnum + 1);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002660
Bram Moolenaar169ebb02016-09-07 23:32:23 +02002661 if (empty)
2662 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002663 // The buffer is empty, replace the first (dummy) line.
Bram Moolenaar169ebb02016-09-07 23:32:23 +02002664 ml_replace(lnum, msg, TRUE);
2665 lnum = 0;
2666 }
2667 else
2668 ml_append(lnum, msg, 0, FALSE);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002669 appended_lines_mark(lnum, 1L);
Bram Moolenaar6b7355a2017-08-04 21:37:54 +02002670
Bram Moolenaarad9ec5e2020-09-10 21:25:45 +02002671 // reset notion of buffer
2672 aucmd_restbuf(&aco);
Bram Moolenaar6b7355a2017-08-04 21:37:54 +02002673
Bram Moolenaar9f5842e2016-05-29 16:17:08 +02002674 if (ch_part->ch_nomodifiable)
2675 buffer->b_p_ma = FALSE;
2676 else
2677 buffer->b_p_ma = save_p_ma;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002678
2679 if (buffer->b_nwindows > 0)
2680 {
2681 win_T *wp;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002682
2683 FOR_ALL_WINDOWS(wp)
2684 {
Bram Moolenaar4641a122019-07-29 22:10:23 +02002685 if (wp->w_buffer == buffer)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002686 {
Bram Moolenaar4641a122019-07-29 22:10:23 +02002687 int move_cursor = save_write_to
2688 ? wp->w_cursor.lnum == lnum + 1
2689 : (wp->w_cursor.lnum == lnum
2690 && wp->w_cursor.col == 0);
2691
2692 // If the cursor is at or above the new line, move it one line
2693 // down. If the topline is outdated update it now.
2694 if (move_cursor || wp->w_topline > buffer->b_ml.ml_line_count)
2695 {
Bram Moolenaarad9ec5e2020-09-10 21:25:45 +02002696 win_T *save_curwin = curwin;
2697
Bram Moolenaar4641a122019-07-29 22:10:23 +02002698 if (move_cursor)
2699 ++wp->w_cursor.lnum;
Bram Moolenaar4641a122019-07-29 22:10:23 +02002700 curwin = wp;
2701 curbuf = curwin->w_buffer;
2702 scroll_cursor_bot(0, FALSE);
2703 curwin = save_curwin;
2704 curbuf = curwin->w_buffer;
2705 }
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002706 }
2707 }
Bram Moolenaar29ae3772017-04-30 19:39:39 +02002708 redraw_buf_and_status_later(buffer, VALID);
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002709 channel_need_redraw = TRUE;
2710 }
2711
2712 if (save_write_to)
2713 {
2714 channel_T *ch;
2715
Bram Moolenaarc667da52019-11-30 20:52:27 +01002716 // Find channels reading from this buffer and adjust their
2717 // next-to-read line number.
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002718 buffer->b_write_to_channel = TRUE;
Bram Moolenaaraeea7212020-04-02 18:50:46 +02002719 FOR_ALL_CHANNELS(ch)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002720 {
2721 chanpart_T *in_part = &ch->ch_part[PART_IN];
2722
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02002723 if (in_part->ch_bufref.br_buf == buffer)
Bram Moolenaar99ef0622016-03-06 20:22:25 +01002724 in_part->ch_buf_bot = buffer->b_ml.ml_line_count;
2725 }
2726 }
2727}
2728
Bram Moolenaar437905c2016-04-26 19:01:05 +02002729 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002730drop_messages(channel_T *channel, ch_part_T part)
Bram Moolenaar437905c2016-04-26 19:01:05 +02002731{
2732 char_u *msg;
2733
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002734 while ((msg = channel_get(channel, part, NULL)) != NULL)
Bram Moolenaar437905c2016-04-26 19:01:05 +02002735 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002736 ch_log(channel, "Dropping message '%s'", (char *)msg);
Bram Moolenaar437905c2016-04-26 19:01:05 +02002737 vim_free(msg);
2738 }
2739}
2740
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002741/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002742 * Invoke a callback for "channel"/"part" if needed.
Bram Moolenaar7f7c3322016-04-18 19:27:24 +02002743 * This does not redraw but sets channel_need_redraw when redraw is needed.
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002744 * Return TRUE when a message was handled, there might be another one.
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002745 */
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002746 static int
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02002747may_invoke_callback(channel_T *channel, ch_part_T part)
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002748{
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002749 char_u *msg = NULL;
2750 typval_T *listtv = NULL;
Bram Moolenaarece61b02016-02-20 21:39:05 +01002751 typval_T argv[CH_JSON_MAX_ARGS];
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002752 int seq_nr = -1;
Bram Moolenaarec68a992016-10-03 21:37:41 +02002753 chanpart_T *ch_part = &channel->ch_part[part];
2754 ch_mode_T ch_mode = ch_part->ch_mode;
2755 cbq_T *cbhead = &ch_part->ch_cb_head;
Bram Moolenaar5983ad02016-03-05 20:54:36 +01002756 cbq_T *cbitem;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02002757 callback_T *callback = NULL;
Bram Moolenaar187db502016-02-27 14:44:26 +01002758 buf_T *buffer = NULL;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002759 char_u *p;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002760
Bram Moolenaar4e221c92016-02-23 13:20:22 +01002761 if (channel->ch_nb_close_cb != NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002762 // this channel is handled elsewhere (netbeans)
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002763 return FALSE;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002764
Bram Moolenaarc667da52019-11-30 20:52:27 +01002765 // Use a message-specific callback, part callback or channel callback
Bram Moolenaar5983ad02016-03-05 20:54:36 +01002766 for (cbitem = cbhead->cq_next; cbitem != NULL; cbitem = cbitem->cq_next)
2767 if (cbitem->cq_seq_nr == 0)
2768 break;
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002769 if (cbitem != NULL)
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02002770 callback = &cbitem->cq_callback;
2771 else if (ch_part->ch_callback.cb_name != NULL)
2772 callback = &ch_part->ch_callback;
2773 else if (channel->ch_callback.cb_name != NULL)
2774 callback = &channel->ch_callback;
Bram Moolenaarc7f0ebc2016-02-27 21:10:09 +01002775
Bram Moolenaarec68a992016-10-03 21:37:41 +02002776 buffer = ch_part->ch_bufref.br_buf;
Bram Moolenaarc4da1132017-07-15 19:39:43 +02002777 if (buffer != NULL && (!bufref_valid(&ch_part->ch_bufref)
2778 || buffer->b_ml.ml_mfp == NULL))
Bram Moolenaarc7f0ebc2016-02-27 21:10:09 +01002779 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002780 // buffer was wiped out or unloaded
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002781 ch_log(channel, "%s buffer has been wiped out", part_names[part]);
Bram Moolenaarec68a992016-10-03 21:37:41 +02002782 ch_part->ch_bufref.br_buf = NULL;
Bram Moolenaarc7f0ebc2016-02-27 21:10:09 +01002783 buffer = NULL;
2784 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002785
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002786 if (ch_mode == MODE_JSON || ch_mode == MODE_JS)
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002787 {
Bram Moolenaarece61b02016-02-20 21:39:05 +01002788 listitem_T *item;
2789 int argc = 0;
2790
Bram Moolenaarc667da52019-11-30 20:52:27 +01002791 // Get any json message in the queue.
Bram Moolenaar958dc692016-12-01 15:34:12 +01002792 if (channel_get_json(channel, part, -1, FALSE, &listtv) == FAIL)
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002793 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002794 // Parse readahead, return when there is still no message.
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002795 channel_parse_json(channel, part);
Bram Moolenaar958dc692016-12-01 15:34:12 +01002796 if (channel_get_json(channel, part, -1, FALSE, &listtv) == FAIL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01002797 return FALSE;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002798 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002799
Bram Moolenaarece61b02016-02-20 21:39:05 +01002800 for (item = listtv->vval.v_list->lv_first;
2801 item != NULL && argc < CH_JSON_MAX_ARGS;
2802 item = item->li_next)
2803 argv[argc++] = item->li_tv;
2804 while (argc < CH_JSON_MAX_ARGS)
2805 argv[argc++].v_type = VAR_UNKNOWN;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002806
Bram Moolenaarece61b02016-02-20 21:39:05 +01002807 if (argv[0].v_type == VAR_STRING)
2808 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002809 // ["cmd", arg] or ["cmd", arg, arg] or ["cmd", arg, arg, arg]
Bram Moolenaarece61b02016-02-20 21:39:05 +01002810 channel_exe_cmd(channel, part, argv);
Bram Moolenaar77073442016-02-13 23:23:53 +01002811 free_tv(listtv);
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002812 return TRUE;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002813 }
2814
Bram Moolenaarece61b02016-02-20 21:39:05 +01002815 if (argv[0].v_type != VAR_NUMBER)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002816 {
Bram Moolenaar77073442016-02-13 23:23:53 +01002817 ch_error(channel,
Bram Moolenaar81661fb2016-02-18 22:23:34 +01002818 "Dropping message with invalid sequence number type");
Bram Moolenaar77073442016-02-13 23:23:53 +01002819 free_tv(listtv);
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002820 return FALSE;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002821 }
Bram Moolenaarece61b02016-02-20 21:39:05 +01002822 seq_nr = argv[0].vval.v_number;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002823 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002824 else if (channel_peek(channel, part) == NULL)
Bram Moolenaard7ece102016-02-02 23:23:02 +01002825 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002826 // nothing to read on RAW or NL channel
Bram Moolenaard7ece102016-02-02 23:23:02 +01002827 return FALSE;
2828 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002829 else
2830 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002831 // If there is no callback or buffer drop the message.
Bram Moolenaar187db502016-02-27 14:44:26 +01002832 if (callback == NULL && buffer == NULL)
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002833 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002834 // If there is a close callback it may use ch_read() to get the
2835 // messages.
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02002836 if (channel->ch_close_cb.cb_name == NULL && !channel->ch_drop_never)
Bram Moolenaar437905c2016-04-26 19:01:05 +02002837 drop_messages(channel, part);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002838 return FALSE;
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002839 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002840
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002841 if (ch_mode == MODE_NL)
2842 {
Bram Moolenaarec68a992016-10-03 21:37:41 +02002843 char_u *nl = NULL;
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002844 char_u *buf;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002845 readq_T *node;
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002846
Bram Moolenaarc667da52019-11-30 20:52:27 +01002847 // See if we have a message ending in NL in the first buffer. If
2848 // not try to concatenate the first and the second buffer.
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002849 while (TRUE)
2850 {
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002851 node = channel_peek(channel, part);
2852 nl = channel_first_nl(node);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002853 if (nl != NULL)
2854 break;
Bram Moolenaar9ed96ef2016-06-04 17:17:11 +02002855 if (channel_collapse(channel, part, TRUE) == FAIL)
Bram Moolenaarec68a992016-10-03 21:37:41 +02002856 {
2857 if (ch_part->ch_fd == INVALID_FD && node->rq_buflen > 0)
2858 break;
Bram Moolenaarc667da52019-11-30 20:52:27 +01002859 return FALSE; // incomplete message
Bram Moolenaarec68a992016-10-03 21:37:41 +02002860 }
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002861 }
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002862 buf = node->rq_buffer;
2863
Bram Moolenaar772153f2019-03-04 12:09:49 +01002864 // Convert NUL to NL, the internal representation.
2865 for (p = buf; (nl == NULL || p < nl)
2866 && p < buf + node->rq_buflen; ++p)
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002867 if (*p == NUL)
2868 *p = NL;
2869
Bram Moolenaar772153f2019-03-04 12:09:49 +01002870 if (nl == NULL)
Bram Moolenaar187db502016-02-27 14:44:26 +01002871 {
Bram Moolenaar772153f2019-03-04 12:09:49 +01002872 // get the whole buffer, drop the NL
2873 msg = channel_get(channel, part, NULL);
2874 }
2875 else if (nl + 1 == buf + node->rq_buflen)
2876 {
2877 // get the whole buffer
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002878 msg = channel_get(channel, part, NULL);
Bram Moolenaar187db502016-02-27 14:44:26 +01002879 *nl = NUL;
2880 }
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002881 else
2882 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002883 // Copy the message into allocated memory (excluding the NL)
2884 // and remove it from the buffer (including the NL).
Bram Moolenaardf44a272020-06-07 20:49:05 +02002885 msg = vim_strnsave(buf, nl - buf);
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002886 channel_consume(channel, part, (int)(nl - buf) + 1);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002887 }
2888 }
2889 else
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002890 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002891 // For a raw channel we don't know where the message ends, just
2892 // get everything we have.
2893 // Convert NUL to NL, the internal representation.
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01002894 msg = channel_get_all(channel, part, NULL);
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02002895 }
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01002896
Bram Moolenaarbf73b912016-03-02 21:16:59 +01002897 if (msg == NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002898 return FALSE; // out of memory (and avoids Coverity warning)
Bram Moolenaarbf73b912016-03-02 21:16:59 +01002899
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002900 argv[1].v_type = VAR_STRING;
2901 argv[1].vval.v_string = msg;
2902 }
2903
Bram Moolenaara07fec92016-02-05 21:04:08 +01002904 if (seq_nr > 0)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002905 {
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002906 int done = FALSE;
Bram Moolenaara07fec92016-02-05 21:04:08 +01002907
Bram Moolenaarc667da52019-11-30 20:52:27 +01002908 // JSON or JS mode: invoke the one-time callback with the matching nr
Bram Moolenaar5983ad02016-03-05 20:54:36 +01002909 for (cbitem = cbhead->cq_next; cbitem != NULL; cbitem = cbitem->cq_next)
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002910 if (cbitem->cq_seq_nr == seq_nr)
Bram Moolenaara07fec92016-02-05 21:04:08 +01002911 {
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002912 invoke_one_time_callback(channel, cbhead, cbitem, argv);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002913 done = TRUE;
Bram Moolenaara07fec92016-02-05 21:04:08 +01002914 break;
2915 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002916 if (!done)
Bram Moolenaar958dc692016-12-01 15:34:12 +01002917 {
2918 if (channel->ch_drop_never)
2919 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002920 // message must be read with ch_read()
Bram Moolenaar958dc692016-12-01 15:34:12 +01002921 channel_push_json(channel, part, listtv);
2922 listtv = NULL;
2923 }
2924 else
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002925 ch_log(channel, "Dropping message %d without callback",
Bram Moolenaar958dc692016-12-01 15:34:12 +01002926 seq_nr);
2927 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002928 }
Bram Moolenaar187db502016-02-27 14:44:26 +01002929 else if (callback != NULL || buffer != NULL)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002930 {
Bram Moolenaar187db502016-02-27 14:44:26 +01002931 if (buffer != NULL)
2932 {
Bram Moolenaarcc7f8be2016-02-29 22:55:56 +01002933 if (msg == NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002934 // JSON or JS mode: re-encode the message.
Bram Moolenaarcc7f8be2016-02-29 22:55:56 +01002935 msg = json_encode(listtv, ch_mode);
2936 if (msg != NULL)
Bram Moolenaarcb8bbe92017-07-16 13:48:22 +02002937 {
Bram Moolenaarc0aa4822017-07-16 14:04:29 +02002938#ifdef FEAT_TERMINAL
Bram Moolenaarcb8bbe92017-07-16 13:48:22 +02002939 if (buffer->b_term != NULL)
2940 write_to_term(buffer, msg, channel);
2941 else
Bram Moolenaarc0aa4822017-07-16 14:04:29 +02002942#endif
Bram Moolenaarcb8bbe92017-07-16 13:48:22 +02002943 append_to_buffer(buffer, msg, channel, part);
2944 }
Bram Moolenaar187db502016-02-27 14:44:26 +01002945 }
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002946
Bram Moolenaar187db502016-02-27 14:44:26 +01002947 if (callback != NULL)
2948 {
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002949 if (cbitem != NULL)
2950 invoke_one_time_callback(channel, cbhead, cbitem, argv);
2951 else
2952 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002953 // invoke the channel callback
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002954 ch_log(channel, "Invoking channel callback %s",
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02002955 (char *)callback->cb_name);
2956 invoke_callback(channel, callback, argv);
Bram Moolenaard6547fc2016-03-03 19:35:02 +01002957 }
Bram Moolenaar187db502016-02-27 14:44:26 +01002958 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002959 }
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002960 else
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02002961 ch_log(channel, "Dropping message %d", seq_nr);
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01002962
Bram Moolenaar19d2f152016-02-01 21:38:19 +01002963 if (listtv != NULL)
Bram Moolenaar77073442016-02-13 23:23:53 +01002964 free_tv(listtv);
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002965 vim_free(msg);
Bram Moolenaardf5b27b2016-02-02 18:43:17 +01002966
2967 return TRUE;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002968}
2969
Bram Moolenaar113e1072019-01-20 15:30:40 +01002970#if defined(FEAT_NETBEANS_INTG) || defined(PROTO)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01002971/*
Bram Moolenaar77073442016-02-13 23:23:53 +01002972 * Return TRUE when channel "channel" is open for writing to.
2973 * Also returns FALSE or invalid "channel".
Bram Moolenaard04a0202016-01-26 23:30:18 +01002974 */
2975 int
Bram Moolenaar77073442016-02-13 23:23:53 +01002976channel_can_write_to(channel_T *channel)
Bram Moolenaard04a0202016-01-26 23:30:18 +01002977{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002978 return channel != NULL && (channel->CH_SOCK_FD != INVALID_FD
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01002979 || channel->CH_IN_FD != INVALID_FD);
Bram Moolenaard04a0202016-01-26 23:30:18 +01002980}
Bram Moolenaar113e1072019-01-20 15:30:40 +01002981#endif
Bram Moolenaard04a0202016-01-26 23:30:18 +01002982
2983/*
Bram Moolenaar77073442016-02-13 23:23:53 +01002984 * Return TRUE when channel "channel" is open for reading or writing.
2985 * Also returns FALSE for invalid "channel".
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002986 */
2987 int
Bram Moolenaar77073442016-02-13 23:23:53 +01002988channel_is_open(channel_T *channel)
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002989{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002990 return channel != NULL && (channel->CH_SOCK_FD != INVALID_FD
Bram Moolenaar42d38a22016-02-20 18:18:59 +01002991 || channel->CH_IN_FD != INVALID_FD
2992 || channel->CH_OUT_FD != INVALID_FD
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01002993 || channel->CH_ERR_FD != INVALID_FD);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01002994}
2995
2996/*
Bram Moolenaar437905c2016-04-26 19:01:05 +02002997 * Return TRUE if "channel" has JSON or other typeahead.
2998 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02002999 static int
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003000channel_has_readahead(channel_T *channel, ch_part_T part)
Bram Moolenaar437905c2016-04-26 19:01:05 +02003001{
3002 ch_mode_T ch_mode = channel->ch_part[part].ch_mode;
3003
3004 if (ch_mode == MODE_JSON || ch_mode == MODE_JS)
3005 {
3006 jsonq_T *head = &channel->ch_part[part].ch_json_head;
Bram Moolenaar437905c2016-04-26 19:01:05 +02003007
Bram Moolenaar4340fc92019-06-28 22:06:49 +02003008 if (head->jq_next == NULL)
3009 // Parse json from readahead, there might be a complete message to
3010 // process.
3011 channel_parse_json(channel, part);
3012
3013 return head->jq_next != NULL;
Bram Moolenaar437905c2016-04-26 19:01:05 +02003014 }
3015 return channel_peek(channel, part) != NULL;
3016}
3017
3018/*
Bram Moolenaar77073442016-02-13 23:23:53 +01003019 * Return a string indicating the status of the channel.
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003020 * If "req_part" is not negative check that part.
Bram Moolenaar77073442016-02-13 23:23:53 +01003021 */
3022 char *
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003023channel_status(channel_T *channel, int req_part)
Bram Moolenaar77073442016-02-13 23:23:53 +01003024{
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003025 ch_part_T part;
Bram Moolenaar437905c2016-04-26 19:01:05 +02003026 int has_readahead = FALSE;
3027
Bram Moolenaar77073442016-02-13 23:23:53 +01003028 if (channel == NULL)
3029 return "fail";
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003030 if (req_part == PART_OUT)
3031 {
3032 if (channel->CH_OUT_FD != INVALID_FD)
3033 return "open";
3034 if (channel_has_readahead(channel, PART_OUT))
Bram Moolenaar437905c2016-04-26 19:01:05 +02003035 has_readahead = TRUE;
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003036 }
3037 else if (req_part == PART_ERR)
3038 {
3039 if (channel->CH_ERR_FD != INVALID_FD)
3040 return "open";
3041 if (channel_has_readahead(channel, PART_ERR))
3042 has_readahead = TRUE;
3043 }
3044 else
3045 {
3046 if (channel_is_open(channel))
3047 return "open";
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003048 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003049 if (channel_has_readahead(channel, part))
3050 {
3051 has_readahead = TRUE;
3052 break;
3053 }
3054 }
Bram Moolenaar437905c2016-04-26 19:01:05 +02003055
3056 if (has_readahead)
3057 return "buffered";
Bram Moolenaar77073442016-02-13 23:23:53 +01003058 return "closed";
3059}
3060
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003061 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003062channel_part_info(channel_T *channel, dict_T *dict, char *name, ch_part_T part)
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003063{
3064 chanpart_T *chanpart = &channel->ch_part[part];
Bram Moolenaarc667da52019-11-30 20:52:27 +01003065 char namebuf[20]; // longest is "sock_timeout"
Bram Moolenaar3f3fbd32016-03-21 12:36:28 +01003066 size_t tail;
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003067 char *status;
Bram Moolenaar573e4452016-03-21 22:35:10 +01003068 char *s = "";
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003069
Bram Moolenaar925ccfd2016-03-28 22:38:02 +02003070 vim_strncpy((char_u *)namebuf, (char_u *)name, 4);
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003071 STRCAT(namebuf, "_");
3072 tail = STRLEN(namebuf);
3073
3074 STRCPY(namebuf + tail, "status");
Bram Moolenaar7ef38102016-09-26 22:36:58 +02003075 if (chanpart->ch_fd != INVALID_FD)
3076 status = "open";
3077 else if (channel_has_readahead(channel, part))
3078 status = "buffered";
3079 else
3080 status = "closed";
Bram Moolenaare0be1672018-07-08 16:50:37 +02003081 dict_add_string(dict, namebuf, (char_u *)status);
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003082
3083 STRCPY(namebuf + tail, "mode");
3084 switch (chanpart->ch_mode)
3085 {
3086 case MODE_NL: s = "NL"; break;
3087 case MODE_RAW: s = "RAW"; break;
3088 case MODE_JSON: s = "JSON"; break;
3089 case MODE_JS: s = "JS"; break;
3090 }
Bram Moolenaare0be1672018-07-08 16:50:37 +02003091 dict_add_string(dict, namebuf, (char_u *)s);
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003092
3093 STRCPY(namebuf + tail, "io");
3094 if (part == PART_SOCK)
3095 s = "socket";
3096 else switch (chanpart->ch_io)
3097 {
3098 case JIO_NULL: s = "null"; break;
3099 case JIO_PIPE: s = "pipe"; break;
3100 case JIO_FILE: s = "file"; break;
3101 case JIO_BUFFER: s = "buffer"; break;
3102 case JIO_OUT: s = "out"; break;
3103 }
Bram Moolenaare0be1672018-07-08 16:50:37 +02003104 dict_add_string(dict, namebuf, (char_u *)s);
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003105
3106 STRCPY(namebuf + tail, "timeout");
Bram Moolenaare0be1672018-07-08 16:50:37 +02003107 dict_add_number(dict, namebuf, chanpart->ch_timeout);
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003108}
3109
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02003110 static void
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003111channel_info(channel_T *channel, dict_T *dict)
3112{
Bram Moolenaare0be1672018-07-08 16:50:37 +02003113 dict_add_number(dict, "id", channel->ch_id);
3114 dict_add_string(dict, "status", (char_u *)channel_status(channel, -1));
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003115
3116 if (channel->ch_hostname != NULL)
3117 {
Bram Moolenaare0be1672018-07-08 16:50:37 +02003118 dict_add_string(dict, "hostname", (char_u *)channel->ch_hostname);
3119 dict_add_number(dict, "port", channel->ch_port);
Bram Moolenaar03602ec2016-03-20 20:57:45 +01003120 channel_part_info(channel, dict, "sock", PART_SOCK);
3121 }
3122 else
3123 {
3124 channel_part_info(channel, dict, "out", PART_OUT);
3125 channel_part_info(channel, dict, "err", PART_ERR);
3126 channel_part_info(channel, dict, "in", PART_IN);
3127 }
3128}
3129
Bram Moolenaar77073442016-02-13 23:23:53 +01003130/*
3131 * Close channel "channel".
Bram Moolenaarc8dcbb12016-02-25 23:10:17 +01003132 * Trigger the close callback if "invoke_close_cb" is TRUE.
Bram Moolenaar187db502016-02-27 14:44:26 +01003133 * Does not clear the buffers.
Bram Moolenaard04a0202016-01-26 23:30:18 +01003134 */
3135 void
Bram Moolenaar8b374212016-02-24 20:43:06 +01003136channel_close(channel_T *channel, int invoke_close_cb)
Bram Moolenaard04a0202016-01-26 23:30:18 +01003137{
Bram Moolenaar81661fb2016-02-18 22:23:34 +01003138 ch_log(channel, "Closing channel");
Bram Moolenaard04a0202016-01-26 23:30:18 +01003139
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01003140#ifdef FEAT_GUI
3141 channel_gui_unregister(channel);
3142#endif
3143
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003144 ch_close_part(channel, PART_SOCK);
3145 ch_close_part(channel, PART_IN);
3146 ch_close_part(channel, PART_OUT);
3147 ch_close_part(channel, PART_ERR);
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01003148
Bram Moolenaara9f02812017-08-05 17:40:38 +02003149 if (invoke_close_cb)
Bram Moolenaar4e221c92016-02-23 13:20:22 +01003150 {
Bram Moolenaara9f02812017-08-05 17:40:38 +02003151 ch_part_T part;
Bram Moolenaar4e221c92016-02-23 13:20:22 +01003152
Bram Moolenaarc667da52019-11-30 20:52:27 +01003153 // Invoke callbacks and flush buffers before the close callback.
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003154 if (channel->ch_close_cb.cb_name != NULL)
Bram Moolenaara9f02812017-08-05 17:40:38 +02003155 ch_log(channel,
3156 "Invoking callbacks and flushing buffers before closing");
3157 for (part = PART_SOCK; part < PART_IN; ++part)
3158 {
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003159 if (channel->ch_close_cb.cb_name != NULL
Bram Moolenaara9f02812017-08-05 17:40:38 +02003160 || channel->ch_part[part].ch_bufref.br_buf != NULL)
3161 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01003162 // Increment the refcount to avoid the channel being freed
3163 // halfway.
Bram Moolenaara9f02812017-08-05 17:40:38 +02003164 ++channel->ch_refcount;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003165 if (channel->ch_close_cb.cb_name == NULL)
Bram Moolenaara9f02812017-08-05 17:40:38 +02003166 ch_log(channel, "flushing %s buffers before closing",
3167 part_names[part]);
3168 while (may_invoke_callback(channel, part))
3169 ;
3170 --channel->ch_refcount;
3171 }
3172 }
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003173
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003174 if (channel->ch_close_cb.cb_name != NULL)
Bram Moolenaara9f02812017-08-05 17:40:38 +02003175 {
3176 typval_T argv[1];
3177 typval_T rettv;
Bram Moolenaara9f02812017-08-05 17:40:38 +02003178
Bram Moolenaarc667da52019-11-30 20:52:27 +01003179 // Increment the refcount to avoid the channel being freed
3180 // halfway.
Bram Moolenaara9f02812017-08-05 17:40:38 +02003181 ++channel->ch_refcount;
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003182 ch_log(channel, "Invoking close callback %s",
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003183 (char *)channel->ch_close_cb.cb_name);
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003184 argv[0].v_type = VAR_CHANNEL;
3185 argv[0].vval.v_channel = channel;
Bram Moolenaarc6538bc2019-08-03 18:17:11 +02003186 call_callback(&channel->ch_close_cb, -1, &rettv, 1, argv);
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003187 clear_tv(&rettv);
Bram Moolenaarcefe4f92016-05-04 21:49:19 +02003188 channel_need_redraw = TRUE;
Bram Moolenaar4e221c92016-02-23 13:20:22 +01003189
Bram Moolenaarc667da52019-11-30 20:52:27 +01003190 // the callback is only called once
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003191 free_callback(&channel->ch_close_cb);
Bram Moolenaar437905c2016-04-26 19:01:05 +02003192
Bram Moolenaara9f02812017-08-05 17:40:38 +02003193 if (channel_need_redraw)
3194 {
3195 channel_need_redraw = FALSE;
Bram Moolenaar02e177d2017-08-26 23:43:28 +02003196 redraw_after_callback(TRUE);
Bram Moolenaara9f02812017-08-05 17:40:38 +02003197 }
Bram Moolenaarcefe4f92016-05-04 21:49:19 +02003198
Bram Moolenaara9f02812017-08-05 17:40:38 +02003199 if (!channel->ch_drop_never)
Bram Moolenaarc667da52019-11-30 20:52:27 +01003200 // any remaining messages are useless now
Bram Moolenaara9f02812017-08-05 17:40:38 +02003201 for (part = PART_SOCK; part < PART_IN; ++part)
3202 drop_messages(channel, part);
Bram Moolenaar5fd8b782017-11-11 15:54:00 +01003203
3204 --channel->ch_refcount;
Bram Moolenaara9f02812017-08-05 17:40:38 +02003205 }
Bram Moolenaar4e221c92016-02-23 13:20:22 +01003206 }
3207
3208 channel->ch_nb_close_cb = NULL;
Bram Moolenaard85f2712017-07-28 21:51:57 +02003209
3210#ifdef FEAT_TERMINAL
3211 term_channel_closed(channel);
3212#endif
Bram Moolenaare0874f82016-01-24 20:36:41 +01003213}
3214
Bram Moolenaard04a0202016-01-26 23:30:18 +01003215/*
Bram Moolenaar0874a832016-09-01 15:11:51 +02003216 * Close the "in" part channel "channel".
3217 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02003218 static void
Bram Moolenaar0874a832016-09-01 15:11:51 +02003219channel_close_in(channel_T *channel)
3220{
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003221 ch_close_part(channel, PART_IN);
Bram Moolenaar0874a832016-09-01 15:11:51 +02003222}
3223
Bram Moolenaaraba680a2017-09-09 16:42:53 +02003224 static void
3225remove_from_writeque(writeq_T *wq, writeq_T *entry)
3226{
3227 ga_clear(&entry->wq_ga);
3228 wq->wq_next = entry->wq_next;
3229 if (wq->wq_next == NULL)
3230 wq->wq_prev = NULL;
3231 else
3232 wq->wq_next->wq_prev = NULL;
Bram Moolenaar5b5adf52017-09-09 18:16:43 +02003233 vim_free(entry);
Bram Moolenaaraba680a2017-09-09 16:42:53 +02003234}
3235
Bram Moolenaar0874a832016-09-01 15:11:51 +02003236/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003237 * Clear the read buffer on "channel"/"part".
Bram Moolenaard04a0202016-01-26 23:30:18 +01003238 */
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003239 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003240channel_clear_one(channel_T *channel, ch_part_T part)
Bram Moolenaard04a0202016-01-26 23:30:18 +01003241{
Bram Moolenaaraba680a2017-09-09 16:42:53 +02003242 chanpart_T *ch_part = &channel->ch_part[part];
3243 jsonq_T *json_head = &ch_part->ch_json_head;
3244 cbq_T *cb_head = &ch_part->ch_cb_head;
Bram Moolenaard04a0202016-01-26 23:30:18 +01003245
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003246 while (channel_peek(channel, part) != NULL)
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003247 vim_free(channel_get(channel, part, NULL));
Bram Moolenaar77073442016-02-13 23:23:53 +01003248
3249 while (cb_head->cq_next != NULL)
Bram Moolenaard46ae142016-02-16 13:33:52 +01003250 {
3251 cbq_T *node = cb_head->cq_next;
3252
3253 remove_cb_node(cb_head, node);
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003254 free_callback(&node->cq_callback);
Bram Moolenaard46ae142016-02-16 13:33:52 +01003255 vim_free(node);
3256 }
Bram Moolenaar77073442016-02-13 23:23:53 +01003257
3258 while (json_head->jq_next != NULL)
Bram Moolenaard04a0202016-01-26 23:30:18 +01003259 {
Bram Moolenaar77073442016-02-13 23:23:53 +01003260 free_tv(json_head->jq_next->jq_value);
3261 remove_json_node(json_head, json_head->jq_next);
Bram Moolenaard04a0202016-01-26 23:30:18 +01003262 }
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01003263
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003264 free_callback(&ch_part->ch_callback);
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003265 ga_clear(&ch_part->ch_block_ids);
Bram Moolenaaraba680a2017-09-09 16:42:53 +02003266
3267 while (ch_part->ch_writeque.wq_next != NULL)
3268 remove_from_writeque(&ch_part->ch_writeque,
3269 ch_part->ch_writeque.wq_next);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003270}
3271
3272/*
3273 * Clear all the read buffers on "channel".
3274 */
3275 void
3276channel_clear(channel_T *channel)
3277{
Bram Moolenaard6051b52016-02-28 15:49:03 +01003278 ch_log(channel, "Clearing channel");
Bram Moolenaard23a8232018-02-10 18:45:26 +01003279 VIM_CLEAR(channel->ch_hostname);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003280 channel_clear_one(channel, PART_SOCK);
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003281 channel_clear_one(channel, PART_OUT);
3282 channel_clear_one(channel, PART_ERR);
Bram Moolenaar5b5adf52017-09-09 18:16:43 +02003283 channel_clear_one(channel, PART_IN);
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02003284 free_callback(&channel->ch_callback);
3285 free_callback(&channel->ch_close_cb);
Bram Moolenaard04a0202016-01-26 23:30:18 +01003286}
3287
Bram Moolenaar77073442016-02-13 23:23:53 +01003288#if defined(EXITFREE) || defined(PROTO)
3289 void
3290channel_free_all(void)
3291{
3292 channel_T *channel;
3293
Bram Moolenaard6051b52016-02-28 15:49:03 +01003294 ch_log(NULL, "channel_free_all()");
Bram Moolenaaraeea7212020-04-02 18:50:46 +02003295 FOR_ALL_CHANNELS(channel)
Bram Moolenaar77073442016-02-13 23:23:53 +01003296 channel_clear(channel);
3297}
3298#endif
3299
3300
Bram Moolenaarc667da52019-11-30 20:52:27 +01003301// Sent when the netbeans channel is found closed when reading.
Bram Moolenaareed284a2016-02-22 23:13:33 +01003302#define DETACH_MSG_RAW "DETACH\n"
Bram Moolenaard04a0202016-01-26 23:30:18 +01003303
Bram Moolenaarc667da52019-11-30 20:52:27 +01003304// Buffer size for reading incoming messages.
Bram Moolenaard04a0202016-01-26 23:30:18 +01003305#define MAXMSGSIZE 4096
3306
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003307#if defined(HAVE_SELECT)
3308/*
3309 * Add write fds where we are waiting for writing to be possible.
3310 */
3311 static int
3312channel_fill_wfds(int maxfd_arg, fd_set *wfds)
3313{
3314 int maxfd = maxfd_arg;
3315 channel_T *ch;
3316
Bram Moolenaaraeea7212020-04-02 18:50:46 +02003317 FOR_ALL_CHANNELS(ch)
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003318 {
3319 chanpart_T *in_part = &ch->ch_part[PART_IN];
3320
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02003321 if (in_part->ch_fd != INVALID_FD
3322 && (in_part->ch_bufref.br_buf != NULL
3323 || in_part->ch_writeque.wq_next != NULL))
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003324 {
3325 FD_SET((int)in_part->ch_fd, wfds);
3326 if ((int)in_part->ch_fd >= maxfd)
3327 maxfd = (int)in_part->ch_fd + 1;
3328 }
3329 }
3330 return maxfd;
3331}
3332#else
3333/*
3334 * Add write fds where we are waiting for writing to be possible.
3335 */
3336 static int
3337channel_fill_poll_write(int nfd_in, struct pollfd *fds)
3338{
3339 int nfd = nfd_in;
3340 channel_T *ch;
3341
Bram Moolenaaraeea7212020-04-02 18:50:46 +02003342 FOR_ALL_CHANNELS(ch)
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003343 {
3344 chanpart_T *in_part = &ch->ch_part[PART_IN];
3345
Bram Moolenaar683b7962017-08-19 15:51:59 +02003346 if (in_part->ch_fd != INVALID_FD
3347 && (in_part->ch_bufref.br_buf != NULL
3348 || in_part->ch_writeque.wq_next != NULL))
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003349 {
3350 in_part->ch_poll_idx = nfd;
3351 fds[nfd].fd = in_part->ch_fd;
3352 fds[nfd].events = POLLOUT;
3353 ++nfd;
3354 }
3355 else
3356 in_part->ch_poll_idx = -1;
3357 }
3358 return nfd;
3359}
3360#endif
3361
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003362typedef enum {
3363 CW_READY,
3364 CW_NOT_READY,
3365 CW_ERROR
3366} channel_wait_result;
3367
Bram Moolenaard04a0202016-01-26 23:30:18 +01003368/*
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003369 * Check for reading from "fd" with "timeout" msec.
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003370 * Return CW_READY when there is something to read.
3371 * Return CW_NOT_READY when there is nothing to read.
3372 * Return CW_ERROR when there is an error.
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003373 */
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003374 static channel_wait_result
Bram Moolenaard8070362016-02-15 21:56:54 +01003375channel_wait(channel_T *channel, sock_T fd, int timeout)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003376{
Bram Moolenaar6463ca22016-02-13 17:04:46 +01003377 if (timeout > 0)
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003378 ch_log(channel, "Waiting for up to %d msec", timeout);
Bram Moolenaard8070362016-02-15 21:56:54 +01003379
Bram Moolenaar4f974752019-02-17 17:44:42 +01003380# ifdef MSWIN
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003381 if (fd != channel->CH_SOCK_FD)
Bram Moolenaard8070362016-02-15 21:56:54 +01003382 {
3383 DWORD nread;
Bram Moolenaar84e1d2b2016-03-28 14:20:41 +02003384 int sleep_time;
Bram Moolenaard8070362016-02-15 21:56:54 +01003385 DWORD deadline = GetTickCount() + timeout;
Bram Moolenaar84e1d2b2016-03-28 14:20:41 +02003386 int delay = 1;
Bram Moolenaard8070362016-02-15 21:56:54 +01003387
Bram Moolenaarc667da52019-11-30 20:52:27 +01003388 // reading from a pipe, not a socket
Bram Moolenaard8070362016-02-15 21:56:54 +01003389 while (TRUE)
3390 {
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003391 int r = PeekNamedPipe((HANDLE)fd, NULL, 0, NULL, &nread, NULL);
3392
3393 if (r && nread > 0)
3394 return CW_READY;
Bram Moolenaar31faed62019-01-22 23:01:40 +01003395
3396 if (channel->ch_named_pipe)
3397 {
3398 DisconnectNamedPipe((HANDLE)fd);
3399 ConnectNamedPipe((HANDLE)fd, NULL);
3400 }
3401 else if (r == 0)
Bram Moolenaarb091f302019-01-19 14:37:00 +01003402 return CW_ERROR;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003403
Bram Moolenaarc667da52019-11-30 20:52:27 +01003404 // perhaps write some buffer lines
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003405 channel_write_any_lines();
3406
Bram Moolenaar84e1d2b2016-03-28 14:20:41 +02003407 sleep_time = deadline - GetTickCount();
3408 if (sleep_time <= 0)
Bram Moolenaard8070362016-02-15 21:56:54 +01003409 break;
Bram Moolenaarc667da52019-11-30 20:52:27 +01003410 // Wait for a little while. Very short at first, up to 10 msec
3411 // after looping a few times.
Bram Moolenaar84e1d2b2016-03-28 14:20:41 +02003412 if (sleep_time > delay)
3413 sleep_time = delay;
3414 Sleep(sleep_time);
3415 delay = delay * 2;
3416 if (delay > 10)
3417 delay = 10;
Bram Moolenaard8070362016-02-15 21:56:54 +01003418 }
Bram Moolenaard8070362016-02-15 21:56:54 +01003419 }
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003420 else
Bram Moolenaard8070362016-02-15 21:56:54 +01003421#endif
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003422 {
Bram Moolenaar9186a272016-02-23 19:34:01 +01003423#if defined(HAVE_SELECT)
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003424 struct timeval tval;
3425 fd_set rfds;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003426 fd_set wfds;
3427 int ret;
3428 int maxfd;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003429
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003430 tval.tv_sec = timeout / 1000;
3431 tval.tv_usec = (timeout % 1000) * 1000;
3432 for (;;)
3433 {
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003434 FD_ZERO(&rfds);
3435 FD_SET((int)fd, &rfds);
3436
Bram Moolenaarc667da52019-11-30 20:52:27 +01003437 // Write lines to a pipe when a pipe can be written to. Need to
3438 // set this every time, some buffers may be done.
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003439 maxfd = (int)fd + 1;
3440 FD_ZERO(&wfds);
3441 maxfd = channel_fill_wfds(maxfd, &wfds);
3442
3443 ret = select(maxfd, &rfds, &wfds, NULL, &tval);
Bram Moolenaar9186a272016-02-23 19:34:01 +01003444# ifdef EINTR
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003445 SOCK_ERRNO;
3446 if (ret == -1 && errno == EINTR)
3447 continue;
Bram Moolenaar9186a272016-02-23 19:34:01 +01003448# endif
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003449 if (ret > 0)
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003450 {
3451 if (FD_ISSET(fd, &rfds))
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003452 return CW_READY;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003453 channel_write_any_lines();
3454 continue;
3455 }
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003456 break;
3457 }
Bram Moolenaar9186a272016-02-23 19:34:01 +01003458#else
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003459 for (;;)
3460 {
3461 struct pollfd fds[MAX_OPEN_CHANNELS + 1];
3462 int nfd = 1;
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003463
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003464 fds[0].fd = fd;
3465 fds[0].events = POLLIN;
3466 nfd = channel_fill_poll_write(nfd, fds);
3467 if (poll(fds, nfd, timeout) > 0)
3468 {
3469 if (fds[0].revents & POLLIN)
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003470 return CW_READY;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02003471 channel_write_any_lines();
3472 continue;
3473 }
3474 break;
3475 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003476#endif
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003477 }
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003478 return CW_NOT_READY;
3479}
3480
3481 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003482ch_close_part_on_error(
3483 channel_T *channel, ch_part_T part, int is_err, char *func)
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003484{
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003485 char msg[] = "%s(): Read %s from ch_part[%d], closing";
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003486
3487 if (is_err)
Bram Moolenaarc667da52019-11-30 20:52:27 +01003488 // Do not call emsg(), most likely the other end just exited.
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003489 ch_error(channel, msg, func, "error", part);
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003490 else
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003491 ch_log(channel, msg, func, "EOF", part);
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003492
Bram Moolenaarc667da52019-11-30 20:52:27 +01003493 // Queue a "DETACH" netbeans message in the command queue in order to
3494 // terminate the netbeans session later. Do not end the session here
3495 // directly as we may be running in the context of a call to
3496 // netbeans_parse_messages():
3497 // netbeans_parse_messages
3498 // -> autocmd triggered while processing the netbeans cmd
3499 // -> ui_breakcheck
3500 // -> gui event loop or select loop
3501 // -> channel_read()
3502 // Only send "DETACH" for a netbeans channel.
Bram Moolenaar715d2852016-04-30 17:06:31 +02003503 if (channel->ch_nb_close_cb != NULL)
Bram Moolenaar8ddef482016-10-09 15:43:25 +02003504 channel_save(channel, PART_SOCK, (char_u *)DETACH_MSG_RAW,
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003505 (int)STRLEN(DETACH_MSG_RAW), FALSE, "PUT ");
3506
Bram Moolenaarc667da52019-11-30 20:52:27 +01003507 // When reading is not possible close this part of the channel. Don't
3508 // close the channel yet, there may be something to read on another part.
3509 // When stdout and stderr use the same FD we get the error only on one of
3510 // them, also close the other.
Bram Moolenaarb0b98d52018-05-05 21:01:00 +02003511 if (part == PART_OUT || part == PART_ERR)
3512 {
3513 ch_part_T other = part == PART_OUT ? PART_ERR : PART_OUT;
3514
3515 if (channel->ch_part[part].ch_fd == channel->ch_part[other].ch_fd)
3516 ch_close_part(channel, other);
3517 }
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003518 ch_close_part(channel, part);
Bram Moolenaarbf981ee2016-05-28 13:20:31 +02003519
3520#ifdef FEAT_GUI
Bram Moolenaarc667da52019-11-30 20:52:27 +01003521 // Stop listening to GUI events right away.
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003522 channel_gui_unregister_one(channel, part);
Bram Moolenaarbf981ee2016-05-28 13:20:31 +02003523#endif
Bram Moolenaarcf7ff702016-05-09 17:20:14 +02003524}
3525
3526 static void
3527channel_close_now(channel_T *channel)
3528{
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003529 ch_log(channel, "Closing channel because all readable fds are closed");
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003530 if (channel->ch_nb_close_cb != NULL)
3531 (*channel->ch_nb_close_cb)();
Bram Moolenaar958dc692016-12-01 15:34:12 +01003532 channel_close(channel, TRUE);
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003533}
3534
3535/*
Bram Moolenaar77073442016-02-13 23:23:53 +01003536 * Read from channel "channel" for as long as there is something to read.
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003537 * "part" is PART_SOCK, PART_OUT or PART_ERR.
Bram Moolenaar655da312016-05-28 22:22:34 +02003538 * The data is put in the read queue. No callbacks are invoked here.
Bram Moolenaard04a0202016-01-26 23:30:18 +01003539 */
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003540 static void
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003541channel_read(channel_T *channel, ch_part_T part, char *func)
Bram Moolenaard04a0202016-01-26 23:30:18 +01003542{
3543 static char_u *buf = NULL;
3544 int len = 0;
3545 int readlen = 0;
Bram Moolenaard8070362016-02-15 21:56:54 +01003546 sock_T fd;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01003547 int use_socket = FALSE;
Bram Moolenaard04a0202016-01-26 23:30:18 +01003548
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003549 fd = channel->ch_part[part].ch_fd;
3550 if (fd == INVALID_FD)
3551 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003552 ch_error(channel, "channel_read() called while %s part is closed",
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003553 part_names[part]);
Bram Moolenaard04a0202016-01-26 23:30:18 +01003554 return;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003555 }
3556 use_socket = fd == channel->CH_SOCK_FD;
Bram Moolenaard04a0202016-01-26 23:30:18 +01003557
Bram Moolenaarc667da52019-11-30 20:52:27 +01003558 // Allocate a buffer to read into.
Bram Moolenaard04a0202016-01-26 23:30:18 +01003559 if (buf == NULL)
3560 {
3561 buf = alloc(MAXMSGSIZE);
3562 if (buf == NULL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01003563 return; // out of memory!
Bram Moolenaard04a0202016-01-26 23:30:18 +01003564 }
3565
Bram Moolenaarc667da52019-11-30 20:52:27 +01003566 // Keep on reading for as long as there is something to read.
3567 // Use select() or poll() to avoid blocking on a message that is exactly
3568 // MAXMSGSIZE long.
Bram Moolenaard04a0202016-01-26 23:30:18 +01003569 for (;;)
3570 {
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003571 if (channel_wait(channel, fd, 0) != CW_READY)
Bram Moolenaard04a0202016-01-26 23:30:18 +01003572 break;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01003573 if (use_socket)
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +01003574 len = sock_read(fd, (char *)buf, MAXMSGSIZE);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01003575 else
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +01003576 len = fd_read(fd, (char *)buf, MAXMSGSIZE);
Bram Moolenaard04a0202016-01-26 23:30:18 +01003577 if (len <= 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +01003578 break; // error or nothing more to read
Bram Moolenaard04a0202016-01-26 23:30:18 +01003579
Bram Moolenaarc667da52019-11-30 20:52:27 +01003580 // Store the read message in the queue.
Bram Moolenaar46c00a62016-03-28 14:11:42 +02003581 channel_save(channel, part, buf, len, FALSE, "RECV ");
Bram Moolenaard04a0202016-01-26 23:30:18 +01003582 readlen += len;
3583 if (len < MAXMSGSIZE)
Bram Moolenaarc667da52019-11-30 20:52:27 +01003584 break; // did read everything that's available
Bram Moolenaard04a0202016-01-26 23:30:18 +01003585 }
3586
Bram Moolenaarc667da52019-11-30 20:52:27 +01003587 // Reading a disconnection (readlen == 0), or an error.
Bram Moolenaarbd73ae12016-02-22 22:19:22 +01003588 if (readlen <= 0)
Bram Moolenaar13ebb032017-08-26 22:02:51 +02003589 {
3590 if (!channel->ch_keep_open)
3591 ch_close_part_on_error(channel, part, (len < 0), func);
3592 }
Bram Moolenaard04a0202016-01-26 23:30:18 +01003593#if defined(CH_HAS_GUI) && defined(FEAT_GUI_GTK)
Bram Moolenaar13ebb032017-08-26 22:02:51 +02003594 else if (CH_HAS_GUI && gtk_main_level() > 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +01003595 // signal the main loop that there is something to read
Bram Moolenaard04a0202016-01-26 23:30:18 +01003596 gtk_main_quit();
3597#endif
3598}
3599
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003600/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003601 * Read from RAW or NL "channel"/"part". Blocks until there is something to
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003602 * read or the timeout expires.
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003603 * When "raw" is TRUE don't block waiting on a NL.
Bram Moolenaar0e57dd82019-09-16 22:56:03 +02003604 * Does not trigger timers or handle messages.
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003605 * Returns what was read in allocated memory.
3606 * Returns NULL in case of error or timeout.
3607 */
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003608 static char_u *
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003609channel_read_block(
3610 channel_T *channel, ch_part_T part, int timeout, int raw, int *outlen)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003611{
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003612 char_u *buf;
3613 char_u *msg;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003614 ch_mode_T mode = channel->ch_part[part].ch_mode;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003615 sock_T fd = channel->ch_part[part].ch_fd;
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003616 char_u *nl;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003617 readq_T *node;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01003618
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003619 ch_log(channel, "Blocking %s read, timeout: %d msec",
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003620 mode == MODE_RAW ? "RAW" : "NL", timeout);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003621
3622 while (TRUE)
3623 {
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003624 node = channel_peek(channel, part);
3625 if (node != NULL)
3626 {
3627 if (mode == MODE_RAW || (mode == MODE_NL
3628 && channel_first_nl(node) != NULL))
Bram Moolenaarc667da52019-11-30 20:52:27 +01003629 // got a complete message
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003630 break;
3631 if (channel_collapse(channel, part, mode == MODE_NL) == OK)
3632 continue;
Bram Moolenaarc667da52019-11-30 20:52:27 +01003633 // If not blocking or nothing more is coming then return what we
3634 // have.
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003635 if (raw || fd == INVALID_FD)
3636 break;
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003637 }
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003638
Bram Moolenaarc667da52019-11-30 20:52:27 +01003639 // Wait for up to the channel timeout.
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003640 if (fd == INVALID_FD)
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003641 return NULL;
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003642 if (channel_wait(channel, fd, timeout) != CW_READY)
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003643 {
3644 ch_log(channel, "Timed out");
3645 return NULL;
3646 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003647 channel_read(channel, part, "channel_read_block");
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003648 }
3649
Bram Moolenaarc667da52019-11-30 20:52:27 +01003650 // We have a complete message now.
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003651 if (mode == MODE_RAW || outlen != NULL)
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003652 {
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003653 msg = channel_get_all(channel, part, outlen);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003654 }
3655 else
3656 {
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003657 char_u *p;
3658
3659 buf = node->rq_buffer;
3660 nl = channel_first_nl(node);
3661
Bram Moolenaarc667da52019-11-30 20:52:27 +01003662 // Convert NUL to NL, the internal representation.
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003663 for (p = buf; (nl == NULL || p < nl) && p < buf + node->rq_buflen; ++p)
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003664 if (*p == NUL)
3665 *p = NL;
3666
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003667 if (nl == NULL)
3668 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01003669 // must be a closed channel with missing NL
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003670 msg = channel_get(channel, part, NULL);
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003671 }
3672 else if (nl + 1 == buf + node->rq_buflen)
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003673 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01003674 // get the whole buffer
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003675 msg = channel_get(channel, part, NULL);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003676 *nl = NUL;
3677 }
3678 else
3679 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01003680 // Copy the message into allocated memory and remove it from the
3681 // buffer.
Bram Moolenaardf44a272020-06-07 20:49:05 +02003682 msg = vim_strnsave(buf, nl - buf);
Bram Moolenaar5f1032d2016-06-07 22:16:36 +02003683 channel_consume(channel, part, (int)(nl - buf) + 1);
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003684 }
3685 }
Bram Moolenaar71eeb742017-09-13 22:18:01 +02003686 if (ch_log_active())
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02003687 ch_log(channel, "Returning %d bytes", (int)STRLEN(msg));
Bram Moolenaar9a6e33a2016-02-16 19:25:12 +01003688 return msg;
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003689}
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003690
Bram Moolenaar0e57dd82019-09-16 22:56:03 +02003691static int channel_blocking_wait = 0;
3692
3693/*
3694 * Return TRUE if in a blocking wait that might trigger callbacks.
3695 */
3696 int
3697channel_in_blocking_wait(void)
3698{
3699 return channel_blocking_wait > 0;
3700}
3701
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003702/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003703 * Read one JSON message with ID "id" from "channel"/"part" and store the
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003704 * result in "rettv".
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01003705 * When "id" is -1 accept any message;
Bram Moolenaar4d919d72016-02-05 22:36:41 +01003706 * Blocks until the message is received or the timeout is reached.
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003707 * In corner cases this can be called recursively, that is why ch_block_ids is
3708 * a list.
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003709 */
Bram Moolenaar958dc692016-12-01 15:34:12 +01003710 static int
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01003711channel_read_json_block(
Bram Moolenaard6051b52016-02-28 15:49:03 +01003712 channel_T *channel,
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003713 ch_part_T part,
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003714 int timeout_arg,
Bram Moolenaard6051b52016-02-28 15:49:03 +01003715 int id,
3716 typval_T **rettv)
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003717{
Bram Moolenaare56bf152016-02-08 23:23:42 +01003718 int more;
Bram Moolenaard8070362016-02-15 21:56:54 +01003719 sock_T fd;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003720 int timeout;
3721 chanpart_T *chanpart = &channel->ch_part[part];
Bram Moolenaar8aeec402019-09-15 23:02:04 +02003722 int retval = FAIL;
Bram Moolenaard7ece102016-02-02 23:23:02 +01003723
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003724 ch_log(channel, "Blocking read JSON for id %d", id);
Bram Moolenaar0e57dd82019-09-16 22:56:03 +02003725 ++channel_blocking_wait;
Bram Moolenaar8aeec402019-09-15 23:02:04 +02003726
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003727 if (id >= 0)
3728 channel_add_block_id(chanpart, id);
Bram Moolenaar8aeec402019-09-15 23:02:04 +02003729
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003730 for (;;)
3731 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01003732 more = channel_parse_json(channel, part);
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003733
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003734 // search for message "id"
Bram Moolenaar958dc692016-12-01 15:34:12 +01003735 if (channel_get_json(channel, part, id, TRUE, rettv) == OK)
Bram Moolenaare56bf152016-02-08 23:23:42 +01003736 {
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003737 ch_log(channel, "Received JSON for id %d", id);
Bram Moolenaar8aeec402019-09-15 23:02:04 +02003738 retval = OK;
3739 break;
Bram Moolenaare56bf152016-02-08 23:23:42 +01003740 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003741
Bram Moolenaard7ece102016-02-02 23:23:02 +01003742 if (!more)
3743 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01003744 // Handle any other messages in the queue. If done some more
3745 // messages may have arrived.
Bram Moolenaard7ece102016-02-02 23:23:02 +01003746 if (channel_parse_messages())
3747 continue;
3748
Bram Moolenaarc667da52019-11-30 20:52:27 +01003749 // Wait for up to the timeout. If there was an incomplete message
3750 // use the deadline for that.
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003751 timeout = timeout_arg;
Bram Moolenaar88989cc2017-02-06 21:56:09 +01003752 if (chanpart->ch_wait_len > 0)
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003753 {
Bram Moolenaar4f974752019-02-17 17:44:42 +01003754#ifdef MSWIN
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003755 timeout = chanpart->ch_deadline - GetTickCount() + 1;
3756#else
3757 {
3758 struct timeval now_tv;
3759
3760 gettimeofday(&now_tv, NULL);
3761 timeout = (chanpart->ch_deadline.tv_sec
3762 - now_tv.tv_sec) * 1000
3763 + (chanpart->ch_deadline.tv_usec
3764 - now_tv.tv_usec) / 1000
3765 + 1;
3766 }
3767#endif
3768 if (timeout < 0)
3769 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01003770 // Something went wrong, channel_parse_json() didn't
3771 // discard message. Cancel waiting.
Bram Moolenaar88989cc2017-02-06 21:56:09 +01003772 chanpart->ch_wait_len = 0;
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003773 timeout = timeout_arg;
3774 }
3775 else if (timeout > timeout_arg)
3776 timeout = timeout_arg;
3777 }
3778 fd = chanpart->ch_fd;
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003779 if (fd == INVALID_FD
3780 || channel_wait(channel, fd, timeout) != CW_READY)
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003781 {
3782 if (timeout == timeout_arg)
3783 {
3784 if (fd != INVALID_FD)
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003785 ch_log(channel, "Timed out on id %d", id);
Bram Moolenaarba61ac02016-03-20 16:40:37 +01003786 break;
3787 }
3788 }
3789 else
3790 channel_read(channel, part, "channel_read_json_block");
Bram Moolenaard7ece102016-02-02 23:23:02 +01003791 }
Bram Moolenaar19d2f152016-02-01 21:38:19 +01003792 }
Bram Moolenaar38ea7842019-06-09 19:51:58 +02003793 if (id >= 0)
3794 channel_remove_block_id(chanpart, id);
Bram Moolenaar0e57dd82019-09-16 22:56:03 +02003795 --channel_blocking_wait;
Bram Moolenaar8aeec402019-09-15 23:02:04 +02003796
Bram Moolenaar8aeec402019-09-15 23:02:04 +02003797 return retval;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01003798}
3799
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003800/*
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02003801 * Get the channel from the argument.
3802 * Returns NULL if the handle is invalid.
3803 * When "check_open" is TRUE check that the channel can be used.
3804 * When "reading" is TRUE "check_open" considers typeahead useful.
3805 * "part" is used to check typeahead, when PART_COUNT use the default part.
3806 */
3807 static channel_T *
3808get_channel_arg(typval_T *tv, int check_open, int reading, ch_part_T part)
3809{
3810 channel_T *channel = NULL;
3811 int has_readahead = FALSE;
3812
3813 if (tv->v_type == VAR_JOB)
3814 {
3815 if (tv->vval.v_job != NULL)
3816 channel = tv->vval.v_job->jv_channel;
3817 }
3818 else if (tv->v_type == VAR_CHANNEL)
3819 {
3820 channel = tv->vval.v_channel;
3821 }
3822 else
3823 {
3824 semsg(_(e_invarg2), tv_get_string(tv));
3825 return NULL;
3826 }
3827 if (channel != NULL && reading)
3828 has_readahead = channel_has_readahead(channel,
3829 part != PART_COUNT ? part : channel_part_read(channel));
3830
3831 if (check_open && (channel == NULL || (!channel_is_open(channel)
3832 && !(reading && has_readahead))))
3833 {
3834 emsg(_("E906: not an open channel"));
3835 return NULL;
3836 }
3837 return channel;
3838}
3839
3840/*
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003841 * Common for ch_read() and ch_readraw().
3842 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02003843 static void
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003844common_channel_read(typval_T *argvars, typval_T *rettv, int raw, int blob)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003845{
3846 channel_T *channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003847 ch_part_T part = PART_COUNT;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003848 jobopt_T opt;
3849 int mode;
3850 int timeout;
3851 int id = -1;
3852 typval_T *listtv = NULL;
3853
Bram Moolenaarc667da52019-11-30 20:52:27 +01003854 // return an empty string by default
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003855 rettv->v_type = VAR_STRING;
3856 rettv->vval.v_string = NULL;
3857
3858 clear_job_options(&opt);
Bram Moolenaar08d384f2017-08-11 21:51:23 +02003859 if (get_job_options(&argvars[1], &opt, JO_TIMEOUT + JO_PART + JO_ID, 0)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003860 == FAIL)
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02003861 goto theend;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003862
Bram Moolenaar437905c2016-04-26 19:01:05 +02003863 if (opt.jo_set & JO_PART)
3864 part = opt.jo_part;
3865 channel = get_channel_arg(&argvars[0], TRUE, TRUE, part);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003866 if (channel != NULL)
3867 {
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003868 if (part == PART_COUNT)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003869 part = channel_part_read(channel);
3870 mode = channel_get_mode(channel, part);
3871 timeout = channel_get_timeout(channel, part);
3872 if (opt.jo_set & JO_TIMEOUT)
3873 timeout = opt.jo_timeout;
3874
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003875 if (blob)
3876 {
3877 int outlen = 0;
3878 char_u *p = channel_read_block(channel, part,
3879 timeout, TRUE, &outlen);
3880 if (p != NULL)
3881 {
3882 blob_T *b = blob_alloc();
3883
3884 if (b != NULL)
3885 {
3886 b->bv_ga.ga_len = outlen;
3887 if (ga_grow(&b->bv_ga, outlen) == FAIL)
3888 blob_free(b);
3889 else
3890 {
3891 memcpy(b->bv_ga.ga_data, p, outlen);
3892 rettv_blob_set(rettv, b);
3893 }
3894 }
3895 vim_free(p);
3896 }
3897 }
3898 else if (raw || mode == MODE_RAW || mode == MODE_NL)
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01003899 rettv->vval.v_string = channel_read_block(channel, part,
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01003900 timeout, raw, NULL);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003901 else
3902 {
3903 if (opt.jo_set & JO_ID)
3904 id = opt.jo_id;
3905 channel_read_json_block(channel, part, timeout, id, &listtv);
3906 if (listtv != NULL)
3907 {
3908 *rettv = *listtv;
3909 vim_free(listtv);
3910 }
3911 else
3912 {
3913 rettv->v_type = VAR_SPECIAL;
3914 rettv->vval.v_number = VVAL_NONE;
3915 }
3916 }
3917 }
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02003918
3919theend:
3920 free_job_options(&opt);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01003921}
3922
Bram Moolenaar80a8d382020-05-03 22:57:32 +02003923#if defined(MSWIN) || defined(__HAIKU__) || defined(FEAT_GUI) || defined(PROTO)
Bram Moolenaarb7522a22016-02-21 17:20:55 +01003924/*
3925 * Check the channels for anything that is ready to be read.
3926 * The data is put in the read queue.
Bram Moolenaar13ebb032017-08-26 22:02:51 +02003927 * if "only_keep_open" is TRUE only check channels where ch_keep_open is set.
Bram Moolenaarb7522a22016-02-21 17:20:55 +01003928 */
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003929 void
Bram Moolenaar13ebb032017-08-26 22:02:51 +02003930channel_handle_events(int only_keep_open)
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003931{
3932 channel_T *channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003933 ch_part_T part;
Bram Moolenaarb7522a22016-02-21 17:20:55 +01003934 sock_T fd;
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003935
Bram Moolenaaraeea7212020-04-02 18:50:46 +02003936 FOR_ALL_CHANNELS(channel)
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003937 {
Bram Moolenaar13ebb032017-08-26 22:02:51 +02003938 if (only_keep_open && !channel->ch_keep_open)
3939 continue;
3940
Bram Moolenaarc667da52019-11-30 20:52:27 +01003941 // check the socket and pipes
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003942 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaarb7522a22016-02-21 17:20:55 +01003943 {
3944 fd = channel->ch_part[part].ch_fd;
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003945 if (fd != INVALID_FD)
3946 {
3947 int r = channel_wait(channel, fd, 0);
3948
3949 if (r == CW_READY)
3950 channel_read(channel, part, "channel_handle_events");
3951 else if (r == CW_ERROR)
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02003952 ch_close_part_on_error(channel, part, TRUE,
3953 "channel_handle_events");
Bram Moolenaarb2658a12016-04-26 17:16:24 +02003954 }
Bram Moolenaarb7522a22016-02-21 17:20:55 +01003955 }
Bram Moolenaar80a8d382020-05-03 22:57:32 +02003956
3957# ifdef __HAIKU__
3958 // Workaround for Haiku: Since select/poll cannot detect EOF from tty,
3959 // should close fds when the job has finished if 'channel' connects to
3960 // the pty.
3961 if (channel->ch_job != NULL)
3962 {
3963 job_T *job = channel->ch_job;
3964
3965 if (job->jv_tty_out != NULL && job->jv_status == JOB_FINISHED)
3966 for (part = PART_SOCK; part < PART_COUNT; ++part)
3967 ch_close_part(channel, part);
3968 }
3969# endif
Bram Moolenaared5a78e2016-02-19 21:05:03 +01003970 }
3971}
Bram Moolenaar80a8d382020-05-03 22:57:32 +02003972#endif
Bram Moolenaar85be35f2016-01-27 21:08:18 +01003973
Bram Moolenaar4ab79682017-08-27 14:50:47 +02003974# if defined(FEAT_GUI) || defined(PROTO)
3975/*
3976 * Return TRUE when there is any channel with a keep_open flag.
3977 */
3978 int
3979channel_any_keep_open()
3980{
3981 channel_T *channel;
3982
Bram Moolenaaraeea7212020-04-02 18:50:46 +02003983 FOR_ALL_CHANNELS(channel)
Bram Moolenaar4ab79682017-08-27 14:50:47 +02003984 if (channel->ch_keep_open)
3985 return TRUE;
3986 return FALSE;
3987}
3988# endif
3989
Bram Moolenaard04a0202016-01-26 23:30:18 +01003990/*
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02003991 * Set "channel"/"part" to non-blocking.
Bram Moolenaarf66a2cd2017-08-18 21:53:22 +02003992 * Only works for sockets and pipes.
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02003993 */
3994 void
3995channel_set_nonblock(channel_T *channel, ch_part_T part)
3996{
3997 chanpart_T *ch_part = &channel->ch_part[part];
Bram Moolenaar0b146882018-09-06 16:27:24 +02003998 int fd = ch_part->ch_fd;
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02003999
4000 if (fd != INVALID_FD)
4001 {
Bram Moolenaar4f974752019-02-17 17:44:42 +01004002#ifdef MSWIN
Bram Moolenaarf66a2cd2017-08-18 21:53:22 +02004003 u_long val = 1;
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004004
Bram Moolenaarf66a2cd2017-08-18 21:53:22 +02004005 ioctlsocket(fd, FIONBIO, &val);
4006#else
Bram Moolenaardc926dd2017-08-19 21:26:44 +02004007 (void)fcntl(fd, F_SETFL, O_NONBLOCK);
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004008#endif
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004009 ch_part->ch_nonblocking = TRUE;
4010 }
4011}
4012
4013/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004014 * Write "buf" (NUL terminated string) to "channel"/"part".
Bram Moolenaard04a0202016-01-26 23:30:18 +01004015 * When "fun" is not NULL an error message might be given.
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01004016 * Return FAIL or OK.
Bram Moolenaard04a0202016-01-26 23:30:18 +01004017 */
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01004018 int
Bram Moolenaar79cbdcb2016-11-11 21:14:03 +01004019channel_send(
4020 channel_T *channel,
4021 ch_part_T part,
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004022 char_u *buf_arg,
4023 int len_arg,
Bram Moolenaar79cbdcb2016-11-11 21:14:03 +01004024 char *fun)
Bram Moolenaard04a0202016-01-26 23:30:18 +01004025{
Bram Moolenaar6463ca22016-02-13 17:04:46 +01004026 int res;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004027 sock_T fd;
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004028 chanpart_T *ch_part = &channel->ch_part[part];
4029 int did_use_queue = FALSE;
Bram Moolenaard04a0202016-01-26 23:30:18 +01004030
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004031 fd = ch_part->ch_fd;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004032 if (fd == INVALID_FD)
Bram Moolenaard04a0202016-01-26 23:30:18 +01004033 {
4034 if (!channel->ch_error && fun != NULL)
4035 {
Bram Moolenaar2f3a90a2017-08-03 14:49:29 +02004036 ch_error(channel, "%s(): write while not connected", fun);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004037 semsg(_("E630: %s(): write while not connected"), fun);
Bram Moolenaard04a0202016-01-26 23:30:18 +01004038 }
4039 channel->ch_error = TRUE;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01004040 return FAIL;
Bram Moolenaard04a0202016-01-26 23:30:18 +01004041 }
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01004042
Bram Moolenaar0b146882018-09-06 16:27:24 +02004043 if (channel->ch_nonblock && !ch_part->ch_nonblocking)
4044 channel_set_nonblock(channel, part);
4045
Bram Moolenaar71eeb742017-09-13 22:18:01 +02004046 if (ch_log_active())
Bram Moolenaar6463ca22016-02-13 17:04:46 +01004047 {
Bram Moolenaar4b16ee72018-08-09 22:15:34 +02004048 ch_log_lead("SEND ", channel, part);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01004049 fprintf(log_fd, "'");
Bram Moolenaar42335f52018-09-13 15:33:43 +02004050 vim_ignored = (int)fwrite(buf_arg, len_arg, 1, log_fd);
Bram Moolenaar6463ca22016-02-13 17:04:46 +01004051 fprintf(log_fd, "'\n");
4052 fflush(log_fd);
Bram Moolenaar101e9922019-09-25 21:43:11 +02004053 did_repeated_msg = 0;
Bram Moolenaar6463ca22016-02-13 17:04:46 +01004054 }
4055
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004056 for (;;)
Bram Moolenaard04a0202016-01-26 23:30:18 +01004057 {
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004058 writeq_T *wq = &ch_part->ch_writeque;
4059 char_u *buf;
4060 int len;
Bram Moolenaar3b5f9292016-01-28 22:37:01 +01004061
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004062 if (wq->wq_next != NULL)
4063 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004064 // first write what was queued
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004065 buf = wq->wq_next->wq_ga.ga_data;
4066 len = wq->wq_next->wq_ga.ga_len;
4067 did_use_queue = TRUE;
4068 }
4069 else
4070 {
4071 if (len_arg == 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +01004072 // nothing to write, called from channel_select_check()
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004073 return OK;
4074 buf = buf_arg;
4075 len = len_arg;
4076 }
4077
4078 if (part == PART_SOCK)
4079 res = sock_write(fd, (char *)buf, len);
4080 else
Bram Moolenaar31faed62019-01-22 23:01:40 +01004081 {
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004082 res = fd_write(fd, (char *)buf, len);
Bram Moolenaar4f974752019-02-17 17:44:42 +01004083#ifdef MSWIN
Bram Moolenaar31faed62019-01-22 23:01:40 +01004084 if (channel->ch_named_pipe && res < 0)
4085 {
4086 DisconnectNamedPipe((HANDLE)fd);
4087 ConnectNamedPipe((HANDLE)fd, NULL);
4088 }
4089#endif
4090 }
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004091 if (res < 0 && (errno == EWOULDBLOCK
4092#ifdef EAGAIN
4093 || errno == EAGAIN
4094#endif
4095 ))
Bram Moolenaarc667da52019-11-30 20:52:27 +01004096 res = 0; // nothing got written
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004097
4098 if (res >= 0 && ch_part->ch_nonblocking)
4099 {
4100 writeq_T *entry = wq->wq_next;
4101
4102 if (did_use_queue)
4103 ch_log(channel, "Sent %d bytes now", res);
4104 if (res == len)
4105 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004106 // Wrote all the buf[len] bytes.
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004107 if (entry != NULL)
4108 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004109 // Remove the entry from the write queue.
Bram Moolenaaraba680a2017-09-09 16:42:53 +02004110 remove_from_writeque(wq, entry);
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004111 continue;
4112 }
4113 if (did_use_queue)
4114 ch_log(channel, "Write queue empty");
4115 }
4116 else
4117 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004118 // Wrote only buf[res] bytes, can't write more now.
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004119 if (entry != NULL)
4120 {
4121 if (res > 0)
4122 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004123 // Remove the bytes that were written.
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004124 mch_memmove(entry->wq_ga.ga_data,
4125 (char *)entry->wq_ga.ga_data + res,
4126 len - res);
4127 entry->wq_ga.ga_len -= res;
4128 }
4129 buf = buf_arg;
4130 len = len_arg;
4131 }
4132 else
4133 {
4134 buf += res;
4135 len -= res;
4136 }
4137 ch_log(channel, "Adding %d bytes to the write queue", len);
4138
Bram Moolenaarc667da52019-11-30 20:52:27 +01004139 // Append the not written bytes of the argument to the write
4140 // buffer. Limit entries to 4000 bytes.
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004141 if (wq->wq_prev != NULL
4142 && wq->wq_prev->wq_ga.ga_len + len < 4000)
4143 {
4144 writeq_T *last = wq->wq_prev;
4145
Bram Moolenaarc667da52019-11-30 20:52:27 +01004146 // append to the last entry
Bram Moolenaar0d071552019-07-08 22:04:03 +02004147 if (len > 0 && ga_grow(&last->wq_ga, len) == OK)
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004148 {
4149 mch_memmove((char *)last->wq_ga.ga_data
4150 + last->wq_ga.ga_len,
4151 buf, len);
4152 last->wq_ga.ga_len += len;
4153 }
4154 }
4155 else
4156 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02004157 writeq_T *last = ALLOC_ONE(writeq_T);
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004158
4159 if (last != NULL)
4160 {
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004161 last->wq_prev = wq->wq_prev;
4162 last->wq_next = NULL;
4163 if (wq->wq_prev == NULL)
4164 wq->wq_next = last;
4165 else
4166 wq->wq_prev->wq_next = last;
4167 wq->wq_prev = last;
4168 ga_init2(&last->wq_ga, 1, 1000);
Bram Moolenaar0d071552019-07-08 22:04:03 +02004169 if (len > 0 && ga_grow(&last->wq_ga, len) == OK)
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004170 {
4171 mch_memmove(last->wq_ga.ga_data, buf, len);
4172 last->wq_ga.ga_len = len;
4173 }
4174 }
4175 }
4176 }
4177 }
4178 else if (res != len)
4179 {
4180 if (!channel->ch_error && fun != NULL)
4181 {
4182 ch_error(channel, "%s(): write failed", fun);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004183 semsg(_("E631: %s(): write failed"), fun);
Bram Moolenaar97bd5e62017-08-18 20:50:30 +02004184 }
4185 channel->ch_error = TRUE;
4186 return FAIL;
4187 }
4188
4189 channel->ch_error = FALSE;
4190 return OK;
4191 }
Bram Moolenaard04a0202016-01-26 23:30:18 +01004192}
4193
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004194/*
4195 * Common for "ch_sendexpr()" and "ch_sendraw()".
4196 * Returns the channel if the caller should read the response.
Bram Moolenaaraad30bb2016-06-26 17:31:03 +02004197 * Sets "part_read" to the read fd.
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004198 * Otherwise returns NULL.
4199 */
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004200 static channel_T *
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004201send_common(
4202 typval_T *argvars,
4203 char_u *text,
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004204 int len,
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004205 int id,
4206 int eval,
4207 jobopt_T *opt,
4208 char *fun,
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004209 ch_part_T *part_read)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004210{
4211 channel_T *channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004212 ch_part_T part_send;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004213
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02004214 clear_job_options(opt);
Bram Moolenaar437905c2016-04-26 19:01:05 +02004215 channel = get_channel_arg(&argvars[0], TRUE, FALSE, 0);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004216 if (channel == NULL)
4217 return NULL;
4218 part_send = channel_part_send(channel);
4219 *part_read = channel_part_read(channel);
4220
Bram Moolenaar08d384f2017-08-11 21:51:23 +02004221 if (get_job_options(&argvars[2], opt, JO_CALLBACK + JO_TIMEOUT, 0) == FAIL)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004222 return NULL;
4223
Bram Moolenaarc667da52019-11-30 20:52:27 +01004224 // Set the callback. An empty callback means no callback and not reading
4225 // the response. With "ch_evalexpr()" and "ch_evalraw()" a callback is not
4226 // allowed.
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004227 if (opt->jo_callback.cb_name != NULL && *opt->jo_callback.cb_name != NUL)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004228 {
4229 if (eval)
4230 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004231 semsg(_("E917: Cannot use a callback with %s()"), fun);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004232 return NULL;
4233 }
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004234 channel_set_req_callback(channel, *part_read, &opt->jo_callback, id);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004235 }
4236
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004237 if (channel_send(channel, part_send, text, len, fun) == OK
Bram Moolenaar3a97bb32019-06-01 13:28:35 +02004238 && opt->jo_callback.cb_name == NULL)
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004239 return channel;
4240 return NULL;
4241}
4242
4243/*
4244 * common for "ch_evalexpr()" and "ch_sendexpr()"
4245 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02004246 static void
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004247ch_expr_common(typval_T *argvars, typval_T *rettv, int eval)
4248{
4249 char_u *text;
4250 typval_T *listtv;
4251 channel_T *channel;
4252 int id;
4253 ch_mode_T ch_mode;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004254 ch_part_T part_send;
4255 ch_part_T part_read;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004256 jobopt_T opt;
4257 int timeout;
4258
Bram Moolenaarc667da52019-11-30 20:52:27 +01004259 // return an empty string by default
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004260 rettv->v_type = VAR_STRING;
4261 rettv->vval.v_string = NULL;
4262
Bram Moolenaar437905c2016-04-26 19:01:05 +02004263 channel = get_channel_arg(&argvars[0], TRUE, FALSE, 0);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004264 if (channel == NULL)
4265 return;
4266 part_send = channel_part_send(channel);
4267
4268 ch_mode = channel_get_mode(channel, part_send);
4269 if (ch_mode == MODE_RAW || ch_mode == MODE_NL)
4270 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004271 emsg(_("E912: cannot use ch_evalexpr()/ch_sendexpr() with a raw or nl channel"));
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004272 return;
4273 }
4274
Bram Moolenaare9d6a292016-03-20 19:31:33 +01004275 id = ++channel->ch_last_msg_id;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004276 text = json_encode_nr_expr(id, &argvars[1],
Bram Moolenaarf1f07922016-08-26 17:58:53 +02004277 (ch_mode == MODE_JS ? JSON_JS : 0) | JSON_NL);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004278 if (text == NULL)
4279 return;
4280
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004281 channel = send_common(argvars, text, (int)STRLEN(text), id, eval, &opt,
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004282 eval ? "ch_evalexpr" : "ch_sendexpr", &part_read);
4283 vim_free(text);
4284 if (channel != NULL && eval)
4285 {
4286 if (opt.jo_set & JO_TIMEOUT)
4287 timeout = opt.jo_timeout;
4288 else
4289 timeout = channel_get_timeout(channel, part_read);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004290 if (channel_read_json_block(channel, part_read, timeout, id, &listtv)
4291 == OK)
4292 {
4293 list_T *list = listtv->vval.v_list;
4294
Bram Moolenaarc667da52019-11-30 20:52:27 +01004295 // Move the item from the list and then change the type to
4296 // avoid the value being freed.
Bram Moolenaar0ff6aad2020-01-29 21:27:21 +01004297 *rettv = list->lv_u.mat.lv_last->li_tv;
4298 list->lv_u.mat.lv_last->li_tv.v_type = VAR_NUMBER;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004299 free_tv(listtv);
4300 }
4301 }
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02004302 free_job_options(&opt);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004303}
4304
4305/*
4306 * common for "ch_evalraw()" and "ch_sendraw()"
4307 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02004308 static void
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004309ch_raw_common(typval_T *argvars, typval_T *rettv, int eval)
4310{
4311 char_u buf[NUMBUFLEN];
4312 char_u *text;
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004313 int len;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004314 channel_T *channel;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004315 ch_part_T part_read;
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004316 jobopt_T opt;
4317 int timeout;
4318
Bram Moolenaarc667da52019-11-30 20:52:27 +01004319 // return an empty string by default
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004320 rettv->v_type = VAR_STRING;
4321 rettv->vval.v_string = NULL;
4322
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004323 if (argvars[1].v_type == VAR_BLOB)
4324 {
4325 text = argvars[1].vval.v_blob->bv_ga.ga_data;
4326 len = argvars[1].vval.v_blob->bv_ga.ga_len;
4327 }
4328 else
4329 {
4330 text = tv_get_string_buf(&argvars[1], buf);
Bram Moolenaare4074252019-01-17 14:31:14 +01004331 len = (int)STRLEN(text);
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004332 }
4333 channel = send_common(argvars, text, len, 0, eval, &opt,
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004334 eval ? "ch_evalraw" : "ch_sendraw", &part_read);
4335 if (channel != NULL && eval)
4336 {
4337 if (opt.jo_set & JO_TIMEOUT)
4338 timeout = opt.jo_timeout;
4339 else
4340 timeout = channel_get_timeout(channel, part_read);
Bram Moolenaar620ca2d2017-12-09 19:13:13 +01004341 rettv->vval.v_string = channel_read_block(channel, part_read,
Bram Moolenaar6e5ea8d2019-01-12 22:47:31 +01004342 timeout, TRUE, NULL);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004343 }
Bram Moolenaar0e4c1de2016-04-07 21:40:38 +02004344 free_job_options(&opt);
Bram Moolenaar8e2c9422016-03-12 13:43:33 +01004345}
4346
Bram Moolenaarc667da52019-11-30 20:52:27 +01004347#define KEEP_OPEN_TIME 20 // msec
Bram Moolenaarf3360612017-10-01 16:21:31 +02004348
Bram Moolenaar8aeec402019-09-15 23:02:04 +02004349#if (defined(UNIX) && !defined(HAVE_SELECT)) || defined(PROTO)
Bram Moolenaare0874f82016-01-24 20:36:41 +01004350/*
4351 * Add open channels to the poll struct.
4352 * Return the adjusted struct index.
4353 * The type of "fds" is hidden to avoid problems with the function proto.
4354 */
4355 int
Bram Moolenaarf3360612017-10-01 16:21:31 +02004356channel_poll_setup(int nfd_in, void *fds_in, int *towait)
Bram Moolenaare0874f82016-01-24 20:36:41 +01004357{
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004358 int nfd = nfd_in;
4359 channel_T *channel;
4360 struct pollfd *fds = fds_in;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004361 ch_part_T part;
Bram Moolenaare0874f82016-01-24 20:36:41 +01004362
Bram Moolenaaraeea7212020-04-02 18:50:46 +02004363 FOR_ALL_CHANNELS(channel)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004364 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004365 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004366 {
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004367 chanpart_T *ch_part = &channel->ch_part[part];
4368
4369 if (ch_part->ch_fd != INVALID_FD)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004370 {
Bram Moolenaarf3360612017-10-01 16:21:31 +02004371 if (channel->ch_keep_open)
4372 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004373 // For unknown reason poll() returns immediately for a
4374 // keep-open channel. Instead of adding it to the fds add
4375 // a short timeout and check, like polling.
Bram Moolenaarf3360612017-10-01 16:21:31 +02004376 if (*towait < 0 || *towait > KEEP_OPEN_TIME)
4377 *towait = KEEP_OPEN_TIME;
4378 }
4379 else
4380 {
4381 ch_part->ch_poll_idx = nfd;
4382 fds[nfd].fd = ch_part->ch_fd;
4383 fds[nfd].events = POLLIN;
4384 nfd++;
4385 }
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004386 }
4387 else
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004388 channel->ch_part[part].ch_poll_idx = -1;
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004389 }
4390 }
Bram Moolenaare0874f82016-01-24 20:36:41 +01004391
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004392 nfd = channel_fill_poll_write(nfd, fds);
4393
Bram Moolenaare0874f82016-01-24 20:36:41 +01004394 return nfd;
4395}
4396
4397/*
4398 * The type of "fds" is hidden to avoid problems with the function proto.
4399 */
4400 int
4401channel_poll_check(int ret_in, void *fds_in)
4402{
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004403 int ret = ret_in;
4404 channel_T *channel;
4405 struct pollfd *fds = fds_in;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004406 ch_part_T part;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004407 int idx;
4408 chanpart_T *in_part;
Bram Moolenaare0874f82016-01-24 20:36:41 +01004409
Bram Moolenaaraeea7212020-04-02 18:50:46 +02004410 FOR_ALL_CHANNELS(channel)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004411 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004412 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004413 {
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004414 idx = channel->ch_part[part].ch_poll_idx;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004415
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004416 if (ret > 0 && idx != -1 && (fds[idx].revents & POLLIN))
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004417 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004418 channel_read(channel, part, "channel_poll_check");
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004419 --ret;
4420 }
Bram Moolenaarf3360612017-10-01 16:21:31 +02004421 else if (channel->ch_part[part].ch_fd != INVALID_FD
4422 && channel->ch_keep_open)
4423 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004424 // polling a keep-open channel
Bram Moolenaarf3360612017-10-01 16:21:31 +02004425 channel_read(channel, part, "channel_poll_check_keep_open");
4426 }
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004427 }
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004428
4429 in_part = &channel->ch_part[PART_IN];
4430 idx = in_part->ch_poll_idx;
4431 if (ret > 0 && idx != -1 && (fds[idx].revents & POLLOUT))
4432 {
Bram Moolenaar683b7962017-08-19 15:51:59 +02004433 channel_write_input(channel);
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004434 --ret;
4435 }
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004436 }
Bram Moolenaare0874f82016-01-24 20:36:41 +01004437
4438 return ret;
4439}
Bram Moolenaarc667da52019-11-30 20:52:27 +01004440#endif // UNIX && !HAVE_SELECT
Bram Moolenaare0874f82016-01-24 20:36:41 +01004441
Bram Moolenaar8aeec402019-09-15 23:02:04 +02004442#if (!defined(MSWIN) && defined(HAVE_SELECT)) || defined(PROTO)
Bram Moolenaarf3360612017-10-01 16:21:31 +02004443
Bram Moolenaare0874f82016-01-24 20:36:41 +01004444/*
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004445 * The "fd_set" type is hidden to avoid problems with the function proto.
Bram Moolenaare0874f82016-01-24 20:36:41 +01004446 */
4447 int
Bram Moolenaarf3360612017-10-01 16:21:31 +02004448channel_select_setup(
4449 int maxfd_in,
4450 void *rfds_in,
4451 void *wfds_in,
4452 struct timeval *tv,
4453 struct timeval **tvp)
Bram Moolenaare0874f82016-01-24 20:36:41 +01004454{
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004455 int maxfd = maxfd_in;
4456 channel_T *channel;
4457 fd_set *rfds = rfds_in;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004458 fd_set *wfds = wfds_in;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004459 ch_part_T part;
Bram Moolenaare0874f82016-01-24 20:36:41 +01004460
Bram Moolenaaraeea7212020-04-02 18:50:46 +02004461 FOR_ALL_CHANNELS(channel)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004462 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004463 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004464 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004465 sock_T fd = channel->ch_part[part].ch_fd;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004466
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004467 if (fd != INVALID_FD)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004468 {
Bram Moolenaarf3360612017-10-01 16:21:31 +02004469 if (channel->ch_keep_open)
4470 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004471 // For unknown reason select() returns immediately for a
4472 // keep-open channel. Instead of adding it to the rfds add
4473 // a short timeout and check, like polling.
Bram Moolenaarf3360612017-10-01 16:21:31 +02004474 if (*tvp == NULL || tv->tv_sec > 0
4475 || tv->tv_usec > KEEP_OPEN_TIME * 1000)
4476 {
4477 *tvp = tv;
4478 tv->tv_sec = 0;
4479 tv->tv_usec = KEEP_OPEN_TIME * 1000;
4480 }
4481 }
4482 else
4483 {
4484 FD_SET((int)fd, rfds);
4485 if (maxfd < (int)fd)
4486 maxfd = (int)fd;
4487 }
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004488 }
4489 }
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004490 }
Bram Moolenaare0874f82016-01-24 20:36:41 +01004491
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004492 maxfd = channel_fill_wfds(maxfd, wfds);
4493
Bram Moolenaare0874f82016-01-24 20:36:41 +01004494 return maxfd;
4495}
4496
4497/*
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004498 * The "fd_set" type is hidden to avoid problems with the function proto.
Bram Moolenaare0874f82016-01-24 20:36:41 +01004499 */
4500 int
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004501channel_select_check(int ret_in, void *rfds_in, void *wfds_in)
Bram Moolenaare0874f82016-01-24 20:36:41 +01004502{
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004503 int ret = ret_in;
4504 channel_T *channel;
4505 fd_set *rfds = rfds_in;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004506 fd_set *wfds = wfds_in;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004507 ch_part_T part;
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004508 chanpart_T *in_part;
Bram Moolenaare0874f82016-01-24 20:36:41 +01004509
Bram Moolenaaraeea7212020-04-02 18:50:46 +02004510 FOR_ALL_CHANNELS(channel)
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004511 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004512 for (part = PART_SOCK; part < PART_IN; ++part)
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004513 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004514 sock_T fd = channel->ch_part[part].ch_fd;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004515
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004516 if (ret > 0 && fd != INVALID_FD && FD_ISSET(fd, rfds))
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004517 {
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004518 channel_read(channel, part, "channel_select_check");
Bram Moolenaar3c518402017-09-08 20:47:00 +02004519 FD_CLR(fd, rfds);
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004520 --ret;
4521 }
Bram Moolenaarf3360612017-10-01 16:21:31 +02004522 else if (fd != INVALID_FD && channel->ch_keep_open)
4523 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004524 // polling a keep-open channel
Bram Moolenaarf3360612017-10-01 16:21:31 +02004525 channel_read(channel, part, "channel_select_check_keep_open");
4526 }
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01004527 }
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004528
4529 in_part = &channel->ch_part[PART_IN];
4530 if (ret > 0 && in_part->ch_fd != INVALID_FD
4531 && FD_ISSET(in_part->ch_fd, wfds))
4532 {
Bram Moolenaar8aeec402019-09-15 23:02:04 +02004533 // Clear the flag first, ch_fd may change in channel_write_input().
Bram Moolenaar3c518402017-09-08 20:47:00 +02004534 FD_CLR(in_part->ch_fd, wfds);
Bram Moolenaar9af97782018-04-03 12:51:01 +02004535 channel_write_input(channel);
Bram Moolenaar8b877ac2016-03-28 19:16:20 +02004536 --ret;
4537 }
Bram Moolenaar80a8d382020-05-03 22:57:32 +02004538
4539# ifdef __HAIKU__
4540 // Workaround for Haiku: Since select/poll cannot detect EOF from tty,
4541 // should close fds when the job has finished if 'channel' connects to
4542 // the pty.
4543 if (channel->ch_job != NULL)
4544 {
4545 job_T *job = channel->ch_job;
4546
4547 if (job->jv_tty_out != NULL && job->jv_status == JOB_FINISHED)
4548 for (part = PART_SOCK; part < PART_COUNT; ++part)
4549 ch_close_part(channel, part);
4550 }
4551# endif
Bram Moolenaar16eb4f82016-02-14 23:02:34 +01004552 }
Bram Moolenaare0874f82016-01-24 20:36:41 +01004553
4554 return ret;
4555}
Bram Moolenaar8aeec402019-09-15 23:02:04 +02004556#endif // !MSWIN && HAVE_SELECT
Bram Moolenaare0874f82016-01-24 20:36:41 +01004557
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01004558/*
Bram Moolenaard7ece102016-02-02 23:23:02 +01004559 * Execute queued up commands.
Bram Moolenaar8aeec402019-09-15 23:02:04 +02004560 * Invoked from the main loop when it's safe to execute received commands,
4561 * and during a blocking wait for ch_evalexpr().
Bram Moolenaard7ece102016-02-02 23:23:02 +01004562 * Return TRUE when something was done.
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01004563 */
Bram Moolenaard7ece102016-02-02 23:23:02 +01004564 int
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01004565channel_parse_messages(void)
4566{
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01004567 channel_T *channel = first_channel;
4568 int ret = FALSE;
4569 int r;
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004570 ch_part_T part = PART_SOCK;
Bram Moolenaar09c56902020-03-28 18:06:31 +01004571 static int recursive = 0;
Bram Moolenaar833eb1d2016-11-24 17:22:50 +01004572#ifdef ELAPSED_FUNC
Bram Moolenaar1ac56c22019-01-17 22:28:22 +01004573 elapsed_T start_tv;
Bram Moolenaar833eb1d2016-11-24 17:22:50 +01004574#endif
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01004575
Bram Moolenaara9c3a302020-03-26 16:03:45 +01004576 // The code below may invoke callbacks, which might call us back.
Bram Moolenaar09c56902020-03-28 18:06:31 +01004577 // In a recursive call channels will not be closed.
4578 ++recursive;
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +02004579 ++safe_to_invoke_callback;
4580
Bram Moolenaara9c3a302020-03-26 16:03:45 +01004581#ifdef ELAPSED_FUNC
4582 ELAPSED_INIT(start_tv);
4583#endif
4584
Bram Moolenaarc667da52019-11-30 20:52:27 +01004585 // Only do this message when another message was given, otherwise we get
4586 // lots of them.
Bram Moolenaar101e9922019-09-25 21:43:11 +02004587 if ((did_repeated_msg & REPEATED_MSG_LOOKING) == 0)
Bram Moolenaard0b65022016-03-06 21:50:33 +01004588 {
4589 ch_log(NULL, "looking for messages on channels");
Bram Moolenaar101e9922019-09-25 21:43:11 +02004590 // now we should also give the message for SafeState
4591 did_repeated_msg = REPEATED_MSG_LOOKING;
Bram Moolenaard0b65022016-03-06 21:50:33 +01004592 }
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01004593 while (channel != NULL)
4594 {
Bram Moolenaar09c56902020-03-28 18:06:31 +01004595 if (recursive == 1)
Bram Moolenaarcf7ff702016-05-09 17:20:14 +02004596 {
Bram Moolenaar09c56902020-03-28 18:06:31 +01004597 if (channel_can_close(channel))
4598 {
4599 channel->ch_to_be_closed = (1U << PART_COUNT);
4600 channel_close_now(channel);
4601 // channel may have been freed, start over
4602 channel = first_channel;
4603 continue;
4604 }
4605 if (channel->ch_to_be_freed || channel->ch_killing)
4606 {
4607 channel_free_contents(channel);
4608 if (channel->ch_job != NULL)
4609 channel->ch_job->jv_channel = NULL;
Bram Moolenaar71658f72020-03-24 20:35:19 +01004610
Bram Moolenaar09c56902020-03-28 18:06:31 +01004611 // free the channel and then start over
4612 channel_free_channel(channel);
4613 channel = first_channel;
4614 continue;
4615 }
4616 if (channel->ch_refcount == 0 && !channel_still_useful(channel))
4617 {
4618 // channel is no longer useful, free it
4619 channel_free(channel);
4620 channel = first_channel;
4621 part = PART_SOCK;
4622 continue;
4623 }
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +02004624 }
Bram Moolenaar09c56902020-03-28 18:06:31 +01004625
Bram Moolenaar187db502016-02-27 14:44:26 +01004626 if (channel->ch_part[part].ch_fd != INVALID_FD
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004627 || channel_has_readahead(channel, part))
Bram Moolenaard7ece102016-02-02 23:23:02 +01004628 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004629 // Increase the refcount, in case the handler causes the channel
4630 // to be unreferenced or closed.
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004631 ++channel->ch_refcount;
4632 r = may_invoke_callback(channel, part);
4633 if (r == OK)
4634 ret = TRUE;
Bram Moolenaar833eb1d2016-11-24 17:22:50 +01004635 if (channel_unref(channel) || (r == OK
4636#ifdef ELAPSED_FUNC
Bram Moolenaarc667da52019-11-30 20:52:27 +01004637 // Limit the time we loop here to 100 msec, otherwise
4638 // Vim becomes unresponsive when the callback takes
4639 // more than a bit of time.
Bram Moolenaar833eb1d2016-11-24 17:22:50 +01004640 && ELAPSED_FUNC(start_tv) < 100L
4641#endif
4642 ))
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004643 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01004644 // channel was freed or something was done, start over
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004645 channel = first_channel;
4646 part = PART_SOCK;
4647 continue;
4648 }
Bram Moolenaard7ece102016-02-02 23:23:02 +01004649 }
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004650 if (part < PART_ERR)
4651 ++part;
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01004652 else
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004653 {
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01004654 channel = channel->ch_next;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004655 part = PART_SOCK;
4656 }
Bram Moolenaar3bece9f2016-02-15 20:39:46 +01004657 }
Bram Moolenaar187db502016-02-27 14:44:26 +01004658
Bram Moolenaar7f7c3322016-04-18 19:27:24 +02004659 if (channel_need_redraw)
Bram Moolenaar187db502016-02-27 14:44:26 +01004660 {
4661 channel_need_redraw = FALSE;
Bram Moolenaar02e177d2017-08-26 23:43:28 +02004662 redraw_after_callback(TRUE);
Bram Moolenaar187db502016-02-27 14:44:26 +01004663 }
4664
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +02004665 --safe_to_invoke_callback;
Bram Moolenaar09c56902020-03-28 18:06:31 +01004666 --recursive;
Bram Moolenaarfb6ffc72016-05-09 17:58:04 +02004667
Bram Moolenaard7ece102016-02-02 23:23:02 +01004668 return ret;
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01004669}
4670
Bram Moolenaarfbc4b4d2016-02-07 15:14:01 +01004671/*
Bram Moolenaar8a8199e2016-11-26 15:13:33 +01004672 * Return TRUE if any channel has readahead. That means we should not block on
4673 * waiting for input.
4674 */
4675 int
4676channel_any_readahead(void)
4677{
4678 channel_T *channel = first_channel;
4679 ch_part_T part = PART_SOCK;
4680
4681 while (channel != NULL)
4682 {
4683 if (channel_has_readahead(channel, part))
4684 return TRUE;
4685 if (part < PART_ERR)
4686 ++part;
4687 else
4688 {
4689 channel = channel->ch_next;
4690 part = PART_SOCK;
4691 }
4692 }
4693 return FALSE;
4694}
4695
4696/*
Bram Moolenaarfbc4b4d2016-02-07 15:14:01 +01004697 * Mark references to lists used in channels.
4698 */
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01004699 int
4700set_ref_in_channel(int copyID)
4701{
Bram Moolenaar77073442016-02-13 23:23:53 +01004702 int abort = FALSE;
4703 channel_T *channel;
Bram Moolenaarb8d49052016-05-01 14:22:16 +02004704 typval_T tv;
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01004705
Bram Moolenaar75a1a942019-06-20 03:45:36 +02004706 for (channel = first_channel; !abort && channel != NULL;
4707 channel = channel->ch_next)
Bram Moolenaarb8d49052016-05-01 14:22:16 +02004708 if (channel_still_useful(channel))
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01004709 {
Bram Moolenaarb8d49052016-05-01 14:22:16 +02004710 tv.v_type = VAR_CHANNEL;
4711 tv.vval.v_channel = channel;
4712 abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL);
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01004713 }
Bram Moolenaar4b6a6dc2016-02-04 22:49:49 +01004714 return abort;
4715}
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01004716
4717/*
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004718 * Return the "part" to write to for "channel".
4719 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02004720 static ch_part_T
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004721channel_part_send(channel_T *channel)
4722{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004723 if (channel->CH_SOCK_FD == INVALID_FD)
4724 return PART_IN;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004725 return PART_SOCK;
4726}
4727
4728/*
4729 * Return the default "part" to read from for "channel".
4730 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02004731 static ch_part_T
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004732channel_part_read(channel_T *channel)
4733{
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004734 if (channel->CH_SOCK_FD == INVALID_FD)
4735 return PART_OUT;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004736 return PART_SOCK;
4737}
4738
4739/*
4740 * Return the mode of "channel"/"part"
Bram Moolenaar77073442016-02-13 23:23:53 +01004741 * If "channel" is invalid returns MODE_JSON.
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01004742 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02004743 static ch_mode_T
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004744channel_get_mode(channel_T *channel, ch_part_T part)
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01004745{
Bram Moolenaar77073442016-02-13 23:23:53 +01004746 if (channel == NULL)
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01004747 return MODE_JSON;
Bram Moolenaar42d38a22016-02-20 18:18:59 +01004748 return channel->ch_part[part].ch_mode;
Bram Moolenaarae8eb3c2016-02-07 21:59:26 +01004749}
4750
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01004751/*
4752 * Return the timeout of "channel"/"part"
4753 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02004754 static int
Bram Moolenaardc0ccae2016-10-09 17:28:01 +02004755channel_get_timeout(channel_T *channel, ch_part_T part)
Bram Moolenaar6f3a5442016-02-20 19:56:13 +01004756{
4757 return channel->ch_part[part].ch_timeout;
4758}
4759
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02004760/*
4761 * "ch_canread()" function
4762 */
4763 void
4764f_ch_canread(typval_T *argvars, typval_T *rettv)
4765{
4766 channel_T *channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
4767
4768 rettv->vval.v_number = 0;
4769 if (channel != NULL)
4770 rettv->vval.v_number = channel_has_readahead(channel, PART_SOCK)
4771 || channel_has_readahead(channel, PART_OUT)
4772 || channel_has_readahead(channel, PART_ERR);
4773}
4774
4775/*
4776 * "ch_close()" function
4777 */
4778 void
4779f_ch_close(typval_T *argvars, typval_T *rettv UNUSED)
4780{
4781 channel_T *channel = get_channel_arg(&argvars[0], TRUE, FALSE, 0);
4782
4783 if (channel != NULL)
4784 {
4785 channel_close(channel, FALSE);
4786 channel_clear(channel);
4787 }
4788}
4789
4790/*
4791 * "ch_close()" function
4792 */
4793 void
4794f_ch_close_in(typval_T *argvars, typval_T *rettv UNUSED)
4795{
4796 channel_T *channel = get_channel_arg(&argvars[0], TRUE, FALSE, 0);
4797
4798 if (channel != NULL)
4799 channel_close_in(channel);
4800}
4801
4802/*
4803 * "ch_getbufnr()" function
4804 */
4805 void
4806f_ch_getbufnr(typval_T *argvars, typval_T *rettv)
4807{
4808 channel_T *channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
4809
4810 rettv->vval.v_number = -1;
4811 if (channel != NULL)
4812 {
4813 char_u *what = tv_get_string(&argvars[1]);
4814 int part;
4815
4816 if (STRCMP(what, "err") == 0)
4817 part = PART_ERR;
4818 else if (STRCMP(what, "out") == 0)
4819 part = PART_OUT;
4820 else if (STRCMP(what, "in") == 0)
4821 part = PART_IN;
4822 else
4823 part = PART_SOCK;
4824 if (channel->ch_part[part].ch_bufref.br_buf != NULL)
4825 rettv->vval.v_number =
4826 channel->ch_part[part].ch_bufref.br_buf->b_fnum;
4827 }
4828}
4829
4830/*
4831 * "ch_getjob()" function
4832 */
4833 void
4834f_ch_getjob(typval_T *argvars, typval_T *rettv)
4835{
4836 channel_T *channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
4837
4838 if (channel != NULL)
4839 {
4840 rettv->v_type = VAR_JOB;
4841 rettv->vval.v_job = channel->ch_job;
4842 if (channel->ch_job != NULL)
4843 ++channel->ch_job->jv_refcount;
4844 }
4845}
4846
4847/*
4848 * "ch_info()" function
4849 */
4850 void
4851f_ch_info(typval_T *argvars, typval_T *rettv UNUSED)
4852{
4853 channel_T *channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
4854
4855 if (channel != NULL && rettv_dict_alloc(rettv) != FAIL)
4856 channel_info(channel, rettv->vval.v_dict);
4857}
4858
4859/*
4860 * "ch_log()" function
4861 */
4862 void
4863f_ch_log(typval_T *argvars, typval_T *rettv UNUSED)
4864{
4865 char_u *msg = tv_get_string(&argvars[0]);
4866 channel_T *channel = NULL;
4867
4868 if (argvars[1].v_type != VAR_UNKNOWN)
4869 channel = get_channel_arg(&argvars[1], FALSE, FALSE, 0);
4870
4871 ch_log(channel, "%s", msg);
4872}
4873
4874/*
4875 * "ch_logfile()" function
4876 */
4877 void
4878f_ch_logfile(typval_T *argvars, typval_T *rettv UNUSED)
4879{
4880 char_u *fname;
4881 char_u *opt = (char_u *)"";
4882 char_u buf[NUMBUFLEN];
4883
Bram Moolenaarc667da52019-11-30 20:52:27 +01004884 // Don't open a file in restricted mode.
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02004885 if (check_restricted() || check_secure())
4886 return;
Bram Moolenaarc5809432021-03-27 21:23:30 +01004887 if (in_vim9script()
4888 && (check_for_string_arg(argvars, 0) == FAIL
4889 || check_for_string_arg(argvars, 1) == FAIL))
4890 return;
4891
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02004892 fname = tv_get_string(&argvars[0]);
4893 if (argvars[1].v_type == VAR_STRING)
4894 opt = tv_get_string_buf(&argvars[1], buf);
4895 ch_logfile(fname, opt);
4896}
4897
4898/*
4899 * "ch_open()" function
4900 */
4901 void
4902f_ch_open(typval_T *argvars, typval_T *rettv)
4903{
4904 rettv->v_type = VAR_CHANNEL;
4905 if (check_restricted() || check_secure())
4906 return;
4907 rettv->vval.v_channel = channel_open_func(argvars);
4908}
4909
4910/*
4911 * "ch_read()" function
4912 */
4913 void
4914f_ch_read(typval_T *argvars, typval_T *rettv)
4915{
4916 common_channel_read(argvars, rettv, FALSE, FALSE);
4917}
4918
4919/*
4920 * "ch_readblob()" function
4921 */
4922 void
4923f_ch_readblob(typval_T *argvars, typval_T *rettv)
4924{
4925 common_channel_read(argvars, rettv, TRUE, TRUE);
4926}
4927
4928/*
4929 * "ch_readraw()" function
4930 */
4931 void
4932f_ch_readraw(typval_T *argvars, typval_T *rettv)
4933{
4934 common_channel_read(argvars, rettv, TRUE, FALSE);
4935}
4936
4937/*
4938 * "ch_evalexpr()" function
4939 */
4940 void
4941f_ch_evalexpr(typval_T *argvars, typval_T *rettv)
4942{
4943 ch_expr_common(argvars, rettv, TRUE);
4944}
4945
4946/*
4947 * "ch_sendexpr()" function
4948 */
4949 void
4950f_ch_sendexpr(typval_T *argvars, typval_T *rettv)
4951{
4952 ch_expr_common(argvars, rettv, FALSE);
4953}
4954
4955/*
4956 * "ch_evalraw()" function
4957 */
4958 void
4959f_ch_evalraw(typval_T *argvars, typval_T *rettv)
4960{
4961 ch_raw_common(argvars, rettv, TRUE);
4962}
4963
4964/*
4965 * "ch_sendraw()" function
4966 */
4967 void
4968f_ch_sendraw(typval_T *argvars, typval_T *rettv)
4969{
4970 ch_raw_common(argvars, rettv, FALSE);
4971}
4972
4973/*
4974 * "ch_setoptions()" function
4975 */
4976 void
4977f_ch_setoptions(typval_T *argvars, typval_T *rettv UNUSED)
4978{
4979 channel_T *channel;
4980 jobopt_T opt;
4981
4982 channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
4983 if (channel == NULL)
4984 return;
4985 clear_job_options(&opt);
4986 if (get_job_options(&argvars[1], &opt,
4987 JO_CB_ALL + JO_TIMEOUT_ALL + JO_MODE_ALL, 0) == OK)
4988 channel_set_options(channel, &opt);
4989 free_job_options(&opt);
4990}
4991
4992/*
4993 * "ch_status()" function
4994 */
4995 void
4996f_ch_status(typval_T *argvars, typval_T *rettv)
4997{
4998 channel_T *channel;
4999 jobopt_T opt;
5000 int part = -1;
5001
Bram Moolenaarc667da52019-11-30 20:52:27 +01005002 // return an empty string by default
Bram Moolenaar0a1f56f2019-06-24 00:43:35 +02005003 rettv->v_type = VAR_STRING;
5004 rettv->vval.v_string = NULL;
5005
5006 channel = get_channel_arg(&argvars[0], FALSE, FALSE, 0);
5007
5008 if (argvars[1].v_type != VAR_UNKNOWN)
5009 {
5010 clear_job_options(&opt);
5011 if (get_job_options(&argvars[1], &opt, JO_PART, 0) == OK
5012 && (opt.jo_set & JO_PART))
5013 part = opt.jo_part;
5014 }
5015
5016 rettv->vval.v_string = vim_strsave((char_u *)channel_status(channel, part));
5017}
5018
Bram Moolenaar1328bde2021-06-05 20:51:38 +02005019/*
5020 * Get a string with information about the channel in "varp" in "buf".
5021 * "buf" must be at least NUMBUFLEN long.
5022 */
5023 char_u *
5024channel_to_string_buf(typval_T *varp, char_u *buf)
5025{
5026 channel_T *channel = varp->vval.v_channel;
5027 char *status = channel_status(channel, -1);
5028
5029 if (channel == NULL)
5030 vim_snprintf((char *)buf, NUMBUFLEN, "channel %s", status);
5031 else
5032 vim_snprintf((char *)buf, NUMBUFLEN,
5033 "channel %d %s", channel->ch_id, status);
5034 return buf;
5035}
5036
Bram Moolenaarc667da52019-11-30 20:52:27 +01005037#endif // FEAT_JOB_CHANNEL