Mercurial > vim
changeset 8031:ece323e2b57f v7.4.1310
commit https://github.com/vim/vim/commit/6463ca229cb9412581419497924c85fcbfc854ab
Author: Bram Moolenaar <Bram@vim.org>
Date: Sat Feb 13 17:04:46 2016 +0100
patch 7.4.1310
Problem: Jobs don't open a channel.
Solution: Create pipes and add them to the channel. Add ch_logfile().
Only Unix for now.
| author | Christian Brabandt <cb@256bit.org> |
|---|---|
| date | Sat, 13 Feb 2016 17:15:05 +0100 |
| parents | 05f57db9d8da |
| children | d23f68fc56df |
| files | runtime/doc/eval.txt src/channel.c src/eval.c src/gui_w48.c src/os_unix.c src/proto/channel.pro src/structs.h src/testdir/test_channel.vim src/testdir/test_channel_pipe.py src/version.c |
| diffstat | 10 files changed, 943 insertions(+), 354 deletions(-) [+] |
line wrap: on
line diff
--- a/runtime/doc/eval.txt +++ b/runtime/doc/eval.txt @@ -1,4 +1,4 @@ -*eval.txt* For Vim version 7.4. Last change: 2016 Feb 07 +*eval.txt* For Vim version 7.4. Last change: 2016 Feb 13 VIM REFERENCE MANUAL by Bram Moolenaar @@ -1416,7 +1416,7 @@ v:exception The value of the exception m *v:false* *false-variable* v:false A Number with value zero. Used to put "false" in JSON. See - |jsonencode()|. + |json_encode()|. When used as a string this evaluates to "false". > echo v:false < false ~ @@ -1556,7 +1556,7 @@ v:mouse_col Column number for a mouse cl *v:none* *none-variable* v:none An empty String. Used to put an empty item in JSON. See - |jsonencode()|. + |json_encode()|. When used as a number this evaluates to zero. When used as a string this evaluates to "none". > echo v:none @@ -1564,7 +1564,7 @@ v:none An empty String. Used to put an *v:null* *null-variable* v:null An empty String. Used to put "null" in JSON. See - |jsonencode()|. + |json_encode()|. When used as a number this evaluates to zero. When used as a string this evaluates to "null". > echo v:null @@ -1737,7 +1737,7 @@ v:throwpoint The point where the excepti *v:true* *true-variable* v:true A Number with value one. Used to put "true" in JSON. See - |jsonencode()|. + |json_encode()|. When used as a string this evaluates to "true". > echo v:true < true ~ @@ -1816,7 +1816,9 @@ call( {func}, {arglist} [, {dict}]) any call {func} with arguments {arglist} ceil( {expr}) Float round {expr} up ch_close( {handle}) none close a channel +ch_logfile( {fname} [, {mode}]) none start logging channel activity ch_open( {address} [, {argdict})] Number open a channel to {address} +ch_readraw( {handle}) String read from channel {handle} ch_sendexpr( {handle}, {expr} [, {callback}]) any send {expr} over JSON channel {handle} ch_sendraw( {handle}, {string} [, {callback}]) @@ -1980,9 +1982,9 @@ mapcheck( {name}[, {mode} [, {abbr}]]) String check for mappings matching {name} match( {expr}, {pat}[, {start}[, {count}]]) Number position where {pat} matches in {expr} -matchadd( {group}, {pattern}[, {priority}[, {id}]]) +matchadd( {group}, {pattern}[, {priority}[, {id} [, {dict}]]]) Number highlight {pattern} with {group} -matchaddpos( {group}, {list}[, {priority}[, {id}]]) +matchaddpos( {group}, {pos}[, {priority}[, {id}[, {dict}]]]) Number highlight positions with {group} matcharg( {nr}) List arguments of |:match| matchdelete( {id}) Number delete match identified by {id} @@ -2274,7 +2276,7 @@ assert_fails({cmd} [, {error}]) *ass assert_false({actual} [, {msg}]) *assert_false()* When {actual} is not false an error message is added to |v:errors|, like with |assert_equal()|. - A value is false when it is zero. When "{actual}" is not a + A value is false when it is zero. When {actual} is not a number the assert fails. When {msg} is omitted an error in the form "Expected False but got {actual}" is produced. @@ -2676,10 +2678,16 @@ confirm({msg} [, {choices} [, {default} don't fit, a vertical layout is used anyway. For some systems the horizontal layout is always used. -ch_close({handle}) *ch_close()* +ch_close({handle}) *ch_close()* Close channel {handle}. See |channel|. {only available when compiled with the |+channel| feature} +ch_logfile( {fname} [, {mode}]) *ch_logfile()* + Start logging channel activity to {fname}. + When {mode} is omitted or "a" append to the file. + When {mode} is "w" start with an empty file. + When {fname} is an empty string: stop logging. + ch_open({address} [, {argdict}]) *ch_open()* Open a channel to {address}. See |channel|. Returns the channel handle on success. Returns a negative @@ -2703,7 +2711,13 @@ ch_open({address} [, {argdict}]) *ch_ Default: 2000. {only available when compiled with the |+channel| feature} -ch_sendexpr({handle}, {expr} [, {callback}]) *ch_sendexpr()* +ch_readraw({handle}) *ch_readraw()* + Read from channel {handle} and return the received message. + This uses the channel timeout. When there is nothing to read + within that time an empty string is returned. + TODO: depends on channel mode. + +ch_sendexpr({handle}, {expr} [, {callback}]) *ch_sendexpr()* Send {expr} over channel {handle}. The {expr} is encoded according to the type of channel. The function cannot be used with a raw channel. See |channel-use|. *E912* @@ -2844,9 +2858,11 @@ deepcopy({expr}[, {noref}]) *deepcopy different from using {expr} directly. When {expr} is a |List| a full copy is created. This means that the original |List| can be changed without changing the - copy, and vice versa. When an item is a |List|, a copy for it - is made, recursively. Thus changing an item in the copy does - not change the contents of the original |List|. + copy, and vice versa. When an item is a |List| or + |Dictionary|, a copy for it is made, recursively. Thus + changing an item in the copy does not change the contents of + the original |List|. + A |Dictionary| is copied in a similar way as a |List|. When {noref} is omitted or zero a contained |List| or |Dictionary| is only copied once. All references point to this single copy. With {noref} set to 1 every occurrence of a @@ -2907,6 +2923,14 @@ diff_hlID({lnum}, {col}) *diff_hlID() The highlight ID can be used with |synIDattr()| to obtain syntax information about the highlighting. + *disable_char_avail_for_testing()* +disable_char_avail_for_testing({expr}) + When {expr} is 1 the internal char_avail() function will + return FALSE. When {expr} is 0 the char_avail() function will + function normally. + Only use this for a test where typeahead causes the test not + to work. E.g., to trigger the CursorMovedI autocommand event. + empty({expr}) *empty()* Return the Number 1 if {expr} is empty, zero otherwise. - A |List| or |Dictionary| is empty when it does not have any @@ -3937,7 +3961,7 @@ glob2regpat({expr}) *glob2regpat()* empty string. *globpath()* -globpath({path}, {expr} [, {nosuf} [, {list} [, {allinks}]]]) +globpath({path}, {expr} [, {nosuf} [, {list} [, {alllinks}]]]) Perform glob() on all directories in {path} and concatenate the results. Example: > :echo globpath(&rtp, "syntax/c.vim") @@ -3963,7 +3987,7 @@ globpath({path}, {expr} [, {nosuf} [, {l they are separated by <NL> characters. Example: > :echo globpath(&rtp, "syntax/c.vim", 0, 1) < - {allinks} is used as with |glob()|. + {alllinks} is used as with |glob()|. The "**" item can be used to search in a directory tree. For example, to find all "README.txt" files in the directories @@ -4314,22 +4338,25 @@ job_start({command} [, {options}]) *j Start a job and return a Job object. Unlike |system()| and |:!cmd| this does not wait for the job to finish. - {command} can be a string. This works best on MS-Windows. On + {command} can be a String. This works best on MS-Windows. On Unix it is split up in white-separated parts to be passed to execvp(). Arguments in double quotes can contain white space. - {command} can be a list, where the first item is the executable + {command} can be a List, where the first item is the executable and further items are the arguments. All items are converted to String. This works best on Unix. + On MS-Windows, job_start() makes a GUI application hidden. If + want to show it, Use |:!start| instead. + The command is executed directly, not through a shell, the 'shell' option is not used. To use the shell: > let job = job_start(["/bin/sh", "-c", "echo hello"]) < Or: > let job = job_start('/bin/sh -c "echo hello"') -< However, the status of the job will now be the status of the - shell, and stopping the job means stopping the shell and the - command may continue to run. +< Note that this will start two processes, the shell and the + command it executes. If you don't want this use the "exec" + shell command. On Unix $PATH is used to search for the executable only when the command does not contain a slash. @@ -4342,12 +4369,10 @@ job_start({command} [, {options}]) *j The returned Job object can be used to get the status with |job_status()| and stop the job with |job_stop()|. - {options} must be a Dictionary. It can contain these optional - items: - killonexit When non-zero kill the job when Vim - exits. (default: 0, don't kill) - - {only available when compiled with the |+channel| feature} + {options} must be a Dictionary. It can contain many optional + items, see |job-options|. + + {only available when compiled with the |+job| feature} job_status({job}) *job_status()* Returns a String with the status of {job}: @@ -4355,27 +4380,40 @@ job_status({job}) *job_status()* "fail" job failed to start "dead" job died or was stopped after running - {only available when compiled with the |+channel| feature} + {only available when compiled with the |+job| feature} job_stop({job} [, {how}]) *job_stop()* Stop the {job}. This can also be used to signal the job. When {how} is omitted or is "term" the job will be terminated - normally. For Unix SIGTERM is sent. - Other values: + normally. For Unix SIGTERM is sent. For MS-Windows + CTRL_BREAK will be sent. This goes to the process group, thus + children may also be affected. + + Other values for Unix: "hup" Unix: SIGHUP "quit" Unix: SIGQUIT "kill" Unix: SIGKILL (strongest way to stop) number Unix: signal with that number + Other values for MS-Windows: + "int" Windows: CTRL_C + "kill" Windows: terminate process forcedly + Others Windows: CTRL_BREAK + + On Unix the signal is sent to the process group. This means + that when the job is "sh -c command" it affects both the shell + and the command. + The result is a Number: 1 if the operation could be executed, 0 if "how" is not supported on the system. Note that even when the operation was executed, whether the job was actually stopped needs to be checked with job_status(). - The operation will even be done when the job wasn't running. - - {only available when compiled with the |+channel| feature} + The status of the job isn't checked, the operation will even + be done when Vim thinks the job isn't running. + + {only available when compiled with the |+job| feature} join({list} [, {sep}]) *join()* Join the items in {list} together into one String. @@ -4773,7 +4811,7 @@ match({expr}, {pat}[, {start}[, {count}] done like 'magic' is set and 'cpoptions' is empty. *matchadd()* *E798* *E799* *E801* -matchadd({group}, {pattern}[, {priority}[, {id} [, {dict}]]]) +matchadd({group}, {pattern}[, {priority}[, {id}[, {dict}]]]) Defines a pattern to be highlighted in the current window (a "match"). It will be highlighted with {group}. Returns an identification number (ID), which can be used to delete the @@ -4809,7 +4847,7 @@ matchadd({group}, {pattern}[, {priority} highlighted matches. The dict can have the following members: conceal Special character to show instead of the - match (only for |hl-Conceal| highlighed + match (only for |hl-Conceal| highlighted matches, see |:syn-cchar|) The number of matches is not limited, as it is the case with @@ -6808,7 +6846,7 @@ type({expr}) The result is a Number, dep :if type(myvar) == type({}) :if type(myvar) == type(0.0) :if type(myvar) == type(v:false) - :if type(myvar) == type(v:none + :if type(myvar) == type(v:none) undofile({name}) *undofile()* Return the name of the undo file that would be used for a file
--- a/src/channel.c +++ b/src/channel.c @@ -14,22 +14,6 @@ #if defined(FEAT_CHANNEL) || defined(PROTO) -/* - * Change the zero to 1 to enable debugging. - * This will write a file "channel_debug.log". - */ -#if 0 -# define CHERROR(fmt, arg) cherror(fmt, arg) -# define CHLOG(idx, send, buf) chlog(idx, send, buf) -# define CHFILE "channel_debug.log" - -static void cherror(char *fmt, char *arg); -static void chlog(int send, char_u *buf); -#else -# define CHERROR(fmt, arg) -# define CHLOG(idx, send, buf) -#endif - /* TRUE when netbeans is running with a GUI. */ #ifdef FEAT_GUI # define CH_HAS_GUI (gui.in_use || gui.starting) @@ -70,63 +54,6 @@ static void chlog(int send, char_u *buf) extern HWND s_hwnd; /* Gvim's Window handle */ #endif -struct readqueue -{ - char_u *buffer; - struct readqueue *next; - struct readqueue *prev; -}; -typedef struct readqueue readq_T; - -struct jsonqueue -{ - typval_T *value; - struct jsonqueue *next; - struct jsonqueue *prev; -}; -typedef struct jsonqueue jsonq_T; - -struct cbqueue -{ - char_u *callback; - int seq_nr; - struct cbqueue *next; - struct cbqueue *prev; -}; -typedef struct cbqueue cbq_T; - -typedef struct { - sock_T ch_fd; /* the socket, -1 for a closed channel */ - int ch_idx; /* used by channel_poll_setup() */ - readq_T ch_head; /* dummy node, header for circular queue */ - - int ch_error; /* When TRUE an error was reported. Avoids giving - * pages full of error messages when the other side - * has exited, only mention the first error until the - * connection works again. */ -#ifdef FEAT_GUI_X11 - XtInputId ch_inputHandler; /* Cookie for input */ -#endif -#ifdef FEAT_GUI_GTK - gint ch_inputHandler; /* Cookie for input */ -#endif -#ifdef WIN32 - int ch_inputHandler; /* simply ret.value of WSAAsyncSelect() */ -#endif - - void (*ch_close_cb)(void); /* callback for when channel is closed */ - - int ch_block_id; /* ID that channel_read_json_block() is - waiting for */ - char_u *ch_callback; /* function to call when a msg is not handled */ - cbq_T ch_cb_head; /* dummy node for pre-request callbacks */ - - ch_mode_T ch_mode; - jsonq_T ch_json_head; /* dummy node, header for circular queue */ - - int ch_timeout; /* request timeout in msec */ -} channel_T; - /* * Information about all channels. * There can be gaps for closed channels, they will be reused later. @@ -134,10 +61,107 @@ typedef struct { static channel_T *channels = NULL; static int channel_count = 0; -/* - * TODO: open debug file when desired. - */ -FILE *debugfd = NULL; +/* Log file opened with ch_logfile(). */ +static FILE *log_fd = NULL; + + void +ch_logfile(FILE *file) +{ + if (log_fd != NULL) + fclose(log_fd); + log_fd = file; + if (log_fd != NULL) + fprintf(log_fd, "==== start log session ====\n"); +} + + static void +ch_log_lead(char *what, int ch_idx) +{ + if (log_fd != NULL) + { + if (ch_idx >= 0) + fprintf(log_fd, "%son %d: ", what, ch_idx); + else + fprintf(log_fd, "%s: ", what); + } +} + + static void +ch_log(int ch_idx, char *msg) +{ + if (log_fd != NULL) + { + ch_log_lead("", ch_idx); + fputs(msg, log_fd); + fflush(log_fd); + } +} + + static void +ch_logn(int ch_idx, char *msg, int nr) +{ + if (log_fd != NULL) + { + ch_log_lead("", ch_idx); + fprintf(log_fd, msg, nr); + fflush(log_fd); + } +} + + static void +ch_logs(int ch_idx, char *msg, char *name) +{ + if (log_fd != NULL) + { + ch_log_lead("", ch_idx); + fprintf(log_fd, msg, name); + fflush(log_fd); + } +} + + static void +ch_logsn(int ch_idx, char *msg, char *name, int nr) +{ + if (log_fd != NULL) + { + ch_log_lead("", ch_idx); + fprintf(log_fd, msg, name, nr); + fflush(log_fd); + } +} + + static void +ch_error(int ch_idx, char *msg) +{ + if (log_fd != NULL) + { + ch_log_lead("ERR ", ch_idx); + fputs(msg, log_fd); + fflush(log_fd); + } +} + + static void +ch_errorn(int ch_idx, char *msg, int nr) +{ + if (log_fd != NULL) + { + ch_log_lead("ERR ", ch_idx); + fprintf(log_fd, msg, nr); + fflush(log_fd); + } +} + + static void +ch_errors(int ch_idx, char *msg, char *arg) +{ + if (log_fd != NULL) + { + ch_log_lead("ERR ", ch_idx); + fprintf(log_fd, msg, arg); + fflush(log_fd); + } +} #ifdef _WIN32 # undef PERROR @@ -181,38 +205,20 @@ strerror_win32(int eno) } #endif -/* - * Add a new channel slot, return the index. - * The channel isn't actually used into ch_fd is set >= 0; - * Returns -1 if all channels are in use. - */ - static int -add_channel(void) + static void +init_channel(int ch_idx) { - int idx; channel_T *ch; - if (channels != NULL) - { - for (idx = 0; idx < channel_count; ++idx) - if (channels[idx].ch_fd < 0) - /* re-use a closed channel slot */ - return idx; - if (channel_count == MAX_OPEN_CHANNELS) - return -1; - } - else - { - channels = (channel_T *)alloc((int)sizeof(channel_T) - * MAX_OPEN_CHANNELS); - if (channels == NULL) - return -1; - } - - ch = &channels[channel_count]; + ch = &channels[ch_idx]; (void)vim_memset(ch, 0, sizeof(channel_T)); - ch->ch_fd = (sock_T)-1; + ch->ch_sock = (sock_T)-1; +#ifdef CHANNEL_PIPES + ch->ch_in = -1; + ch->ch_out = -1; + ch->ch_err = -1; +#endif #ifdef FEAT_GUI_X11 ch->ch_inputHandler = (XtInputId)NULL; #endif @@ -231,7 +237,40 @@ add_channel(void) ch->ch_json_head.prev = &ch->ch_json_head; ch->ch_timeout = 2000; +} +/* + * Add a new channel slot, return the index. + * The channel isn't actually used into ch_sock is set >= 0; + * Returns -1 if all channels are in use. + */ + int +add_channel(void) +{ + int ch_idx; + + if (channels != NULL) + { + for (ch_idx = 0; ch_idx < channel_count; ++ch_idx) + if (!channel_is_open(ch_idx)) + { + /* re-use a closed channel slot */ + init_channel(ch_idx); + ch_log(ch_idx, "Opening channel (used before)\n"); + return ch_idx; + } + if (channel_count == MAX_OPEN_CHANNELS) + return -1; + } + else + { + channels = (channel_T *)alloc((int)sizeof(channel_T) + * MAX_OPEN_CHANNELS); + if (channels == NULL) + return -1; + } + init_channel(channel_count); + ch_log(channel_count, "Opening new channel\n"); return channel_count++; } @@ -245,7 +284,7 @@ messageFromNetbeans(XtPointer clientData int *unused1 UNUSED, XtInputId *unused2 UNUSED) { - channel_read((int)(long)clientData); + channel_read((int)(long)clientData, FALSE, "messageFromNetbeans"); } #endif @@ -255,27 +294,28 @@ messageFromNetbeans(gpointer clientData, gint unused1 UNUSED, GdkInputCondition unused2 UNUSED) { - channel_read((int)(long)clientData); + channel_read((int)(long)clientData, FALSE, "messageFromNetbeans"); } #endif static void -channel_gui_register(int idx) +channel_gui_register(int ch_idx) { - channel_T *channel = &channels[idx]; + channel_T *channel = &channels[ch_idx]; if (!CH_HAS_GUI) return; + /* TODO: pipes */ # ifdef FEAT_GUI_X11 /* tell notifier we are interested in being called * when there is input on the editor connection socket */ if (channel->ch_inputHandler == (XtInputId)NULL) channel->ch_inputHandler = - XtAppAddInput((XtAppContext)app_context, channel->ch_fd, + XtAppAddInput((XtAppContext)app_context, channel->ch_sock, (XtPointer)(XtInputReadMask + XtInputExceptMask), - messageFromNetbeans, (XtPointer)(long)idx); + messageFromNetbeans, (XtPointer)(long)ch_idx); # else # ifdef FEAT_GUI_GTK /* @@ -284,9 +324,9 @@ channel_gui_register(int idx) */ if (channel->ch_inputHandler == 0) channel->ch_inputHandler = - gdk_input_add((gint)channel->ch_fd, (GdkInputCondition) + gdk_input_add((gint)channel->ch_sock, (GdkInputCondition) ((int)GDK_INPUT_READ + (int)GDK_INPUT_EXCEPTION), - messageFromNetbeans, (gpointer)(long)idx); + messageFromNetbeans, (gpointer)(long)ch_idx); # else # ifdef FEAT_GUI_W32 /* @@ -295,7 +335,7 @@ channel_gui_register(int idx) */ if (channel->ch_inputHandler == -1) channel->ch_inputHandler = - WSAAsyncSelect(channel->ch_fd, s_hwnd, WM_NETBEANS, FD_READ); + WSAAsyncSelect(channel->ch_sock, s_hwnd, WM_NETBEANS, FD_READ); # endif # endif # endif @@ -311,15 +351,17 @@ channel_gui_register_all(void) int i; for (i = 0; i < channel_count; ++i) - if (channels[i].ch_fd >= 0) + /* TODO: pipes */ + if (channels[i].ch_sock >= 0) channel_gui_register(i); } static void -channel_gui_unregister(int idx) +channel_gui_unregister(int ch_idx) { - channel_T *channel = &channels[idx]; + channel_T *channel = &channels[ch_idx]; + /* TODO: pipes */ # ifdef FEAT_GUI_X11 if (channel->ch_inputHandler != (XtInputId)NULL) { @@ -337,7 +379,7 @@ channel_gui_unregister(int idx) # ifdef FEAT_GUI_W32 if (channel->ch_inputHandler == 0) { - WSAAsyncSelect(channel->ch_fd, s_hwnd, 0, 0); + WSAAsyncSelect(channel->ch_sock, s_hwnd, 0, 0); channel->ch_inputHandler = -1; } # endif @@ -348,7 +390,7 @@ channel_gui_unregister(int idx) #endif /* - * Open a channel to "hostname":"port". + * Open a socket channel to "hostname":"port". * Returns the channel number for success. * Returns a negative number for failure. */ @@ -364,24 +406,24 @@ channel_open(char *hostname, int port_in #else int port = port_in; #endif - int idx; + int ch_idx; int ret; #ifdef WIN32 channel_init_winsock(); #endif - idx = add_channel(); - if (idx < 0) + ch_idx = add_channel(); + if (ch_idx < 0) { - CHERROR("All channels are in use\n", ""); + ch_error(-1, "All channels are in use.\n"); EMSG(_("E897: All channels are in use")); return -1; } if ((sd = (sock_T)socket(AF_INET, SOCK_STREAM, 0)) == (sock_T)-1) { - CHERROR("error in socket() in channel_open()\n", ""); + ch_error(-1, "in socket() in channel_open().\n"); PERROR("E898: socket() in channel_open()"); return -1; } @@ -393,7 +435,7 @@ channel_open(char *hostname, int port_in server.sin_port = htons(port); if ((host = gethostbyname(hostname)) == NULL) { - CHERROR("error in gethostbyname() in channel_open()\n", ""); + ch_error(-1, "in gethostbyname() in channel_open()\n"); PERROR("E901: gethostbyname() in channel_open()"); sock_close(sd); return -1; @@ -412,21 +454,27 @@ channel_open(char *hostname, int port_in ) { SOCK_ERRNO; - CHERROR("channel_open: Connect failed with errno %d\n", errno); + ch_errorn(-1, "channel_open: Connect failed with errno %d\n", + errno); sock_close(sd); return -1; } } /* Try connecting to the server. */ + ch_logsn(-1, "Connecting to %s port %d", hostname, port); ret = connect(sd, (struct sockaddr *)&server, sizeof(server)); SOCK_ERRNO; if (ret < 0) { - if (errno != EWOULDBLOCK && errno != EINPROGRESS) + if (errno != EWOULDBLOCK +#ifdef EINPROGRESS + && errno != EINPROGRESS +#endif + ) { - CHERROR("channel_open: Connect failed with errno %d\n", errno); - CHERROR("Cannot connect to port\n", ""); + ch_errorn(-1, "channel_open: Connect failed with errno %d\n", + errno); PERROR(_("E902: Cannot connect to port")); sock_close(sd); return -1; @@ -446,8 +494,8 @@ channel_open(char *hostname, int port_in if (ret < 0) { SOCK_ERRNO; - CHERROR("channel_open: Connect failed with errno %d\n", errno); - CHERROR("Cannot connect to port\n", ""); + ch_errorn(-1, "channel_open: Connect failed with errno %d\n", + errno); PERROR(_("E902: Cannot connect to port")); sock_close(sd); return -1; @@ -477,7 +525,7 @@ channel_open(char *hostname, int port_in if ((sd = (sock_T)socket(AF_INET, SOCK_STREAM, 0)) == (sock_T)-1) { SOCK_ERRNO; - CHERROR("socket() retry in channel_open()\n", ""); + ch_log(-1, "socket() retry in channel_open()\n"); PERROR("E900: socket() retry in channel_open()"); return -1; } @@ -490,7 +538,7 @@ channel_open(char *hostname, int port_in while (retries-- && ((errno == ECONNREFUSED) || (errno == EINTR))) { - CHERROR("retrying...\n", ""); + ch_log(-1, "retrying...\n"); mch_delay(3000L, TRUE); ui_breakcheck(); if (got_int) @@ -509,7 +557,7 @@ channel_open(char *hostname, int port_in if (!success) { /* Get here when the server can't be found. */ - CHERROR("Cannot connect to port after retry\n", ""); + ch_error(-1, "Cannot connect to port after retry\n"); PERROR(_("E899: Cannot connect to port after retry2")); sock_close(sd); return -1; @@ -517,51 +565,69 @@ channel_open(char *hostname, int port_in } } - channels[idx].ch_fd = sd; - channels[idx].ch_close_cb = close_cb; + channels[ch_idx].ch_sock = sd; + channels[ch_idx].ch_close_cb = close_cb; #ifdef FEAT_GUI - channel_gui_register(idx); + channel_gui_register(ch_idx); #endif - return idx; + return ch_idx; } -/* - * Set the json mode of channel "idx" to "ch_mode". - */ +#if defined(CHANNEL_PIPES) || defined(PROTO) void -channel_set_json_mode(int idx, ch_mode_T ch_mode) +channel_set_pipes(int ch_idx, int in, int out, int err) { - channels[idx].ch_mode = ch_mode; + channel_T *channel = &channels[ch_idx]; + + channel->ch_in = in; + channel->ch_out = out; + channel->ch_err = err; +} +#endif + + void +channel_set_job(int ch_idx, job_T *job) +{ + channels[ch_idx].ch_job = job; } /* - * Set the read timeout of channel "idx". + * Set the json mode of channel "ch_idx" to "ch_mode". */ void -channel_set_timeout(int idx, int timeout) +channel_set_json_mode(int ch_idx, ch_mode_T ch_mode) { - channels[idx].ch_timeout = timeout; + channels[ch_idx].ch_mode = ch_mode; } /* - * Set the callback for channel "idx". + * Set the read timeout of channel "ch_idx". */ void -channel_set_callback(int idx, char_u *callback) +channel_set_timeout(int ch_idx, int timeout) { - vim_free(channels[idx].ch_callback); - channels[idx].ch_callback = vim_strsave(callback); + channels[ch_idx].ch_timeout = timeout; } /* - * Set the callback for channel "idx" for the response with "id". + * Set the callback for channel "ch_idx". */ void -channel_set_req_callback(int idx, char_u *callback, int id) +channel_set_callback(int ch_idx, char_u *callback) { - cbq_T *cbhead = &channels[idx].ch_cb_head; + vim_free(channels[ch_idx].ch_callback); + channels[ch_idx].ch_callback = vim_strsave(callback); +} + +/* + * Set the callback for channel "ch_idx" for the response with "id". + */ + void +channel_set_req_callback(int ch_idx, char_u *callback, int id) +{ + cbq_T *cbhead = &channels[ch_idx].ch_cb_head; cbq_T *item = (cbq_T *)alloc((int)sizeof(cbq_T)); if (item != NULL) @@ -576,16 +642,16 @@ channel_set_req_callback(int idx, char_u } /* - * Invoke the "callback" on channel "idx". + * Invoke the "callback" on channel "ch_idx". */ static void -invoke_callback(int idx, char_u *callback, typval_T *argv) +invoke_callback(int ch_idx, char_u *callback, typval_T *argv) { typval_T rettv; int dummy; argv[0].v_type = VAR_NUMBER; - argv[0].vval.v_number = idx; + argv[0].vval.v_number = ch_idx; call_func(callback, (int)STRLEN(callback), &rettv, 2, argv, 0L, 0L, &dummy, TRUE, NULL); @@ -602,9 +668,9 @@ invoke_callback(int idx, char_u *callbac * Returns NULL if there is nothing. */ char_u * -channel_get(int idx) +channel_get(int ch_idx) { - readq_T *head = &channels[idx].ch_head; + readq_T *head = &channels[ch_idx].ch_head; readq_T *node; char_u *p; @@ -623,23 +689,23 @@ channel_get(int idx) * Returns the whole buffer contents concatenated. */ static char_u * -channel_get_all(int idx) +channel_get_all(int ch_idx) { /* Concatenate everything into one buffer. * TODO: avoid multiple allocations. */ - while (channel_collapse(idx) == OK) + while (channel_collapse(ch_idx) == OK) ; - return channel_get(idx); + return channel_get(ch_idx); } /* - * Collapses the first and second buffer in the channel "idx". + * Collapses the first and second buffer in the channel "ch_idx". * Returns FAIL if that is not possible. */ int -channel_collapse(int idx) +channel_collapse(int ch_idx) { - readq_T *head = &channels[idx].ch_head; + readq_T *head = &channels[ch_idx].ch_head; readq_T *node = head->next; char_u *p; @@ -799,12 +865,12 @@ channel_get_json(int ch_idx, int id, typ } /* - * Execute a command received over channel "idx". + * Execute a command received over channel "ch_idx". * "cmd" is the command string, "arg2" the second argument. * "arg3" is the third argument, NULL if missing. */ static void -channel_exe_cmd(int idx, char_u *cmd, typval_T *arg2, typval_T *arg3) +channel_exe_cmd(int ch_idx, char_u *cmd, typval_T *arg2, typval_T *arg3) { char_u *arg; @@ -862,7 +928,7 @@ channel_exe_cmd(int idx, char_u *cmd, ty typval_T *tv; typval_T err_tv; char_u *json = NULL; - channel_T *channel = &channels[idx]; + channel_T *channel = &channels[ch_idx]; int options = channel->ch_mode == MODE_JS ? JSON_JS : 0; /* Don't pollute the display with errors. */ @@ -885,7 +951,7 @@ channel_exe_cmd(int idx, char_u *cmd, ty } if (json != NULL) { - channel_send(idx, json, "eval"); + channel_send(ch_idx, json, "eval"); vim_free(json); } } @@ -899,11 +965,11 @@ channel_exe_cmd(int idx, char_u *cmd, ty } /* - * Invoke a callback for channel "idx" if needed. + * Invoke a callback for channel "ch_idx" if needed. * Return OK when a message was handled, there might be another one. */ static int -may_invoke_callback(int idx) +may_invoke_callback(int ch_idx) { char_u *msg = NULL; typval_T *listtv = NULL; @@ -911,7 +977,7 @@ may_invoke_callback(int idx) typval_T *typetv; typval_T argv[3]; int seq_nr = -1; - channel_T *channel = &channels[idx]; + channel_T *channel = &channels[ch_idx]; ch_mode_T ch_mode = channel->ch_mode; if (channel->ch_close_cb != NULL) @@ -921,11 +987,11 @@ may_invoke_callback(int idx) if (ch_mode != MODE_RAW) { /* Get any json message in the queue. */ - if (channel_get_json(idx, -1, &listtv) == FAIL) + if (channel_get_json(ch_idx, -1, &listtv) == FAIL) { /* Parse readahead, return when there is still no message. */ - channel_parse_json(idx); - if (channel_get_json(idx, -1, &listtv) == FAIL) + channel_parse_json(ch_idx); + if (channel_get_json(ch_idx, -1, &listtv) == FAIL) return FALSE; } @@ -940,56 +1006,69 @@ may_invoke_callback(int idx) /* ["cmd", arg] or ["cmd", arg, arg] */ if (list->lv_len == 3) arg3 = &list->lv_last->li_tv; - channel_exe_cmd(idx, cmd, &argv[1], arg3); + ch_logs(ch_idx, "Executing %s command", (char *)cmd); + channel_exe_cmd(ch_idx, cmd, &argv[1], arg3); clear_tv(listtv); return TRUE; } if (typetv->v_type != VAR_NUMBER) { - /* TODO: give error */ + ch_error(ch_idx, + "Dropping message with invalid sequence number type\n"); clear_tv(listtv); return FALSE; } seq_nr = typetv->vval.v_number; } - else if (channel_peek(idx) == NULL) + else if (channel_peek(ch_idx) == NULL) { /* nothing to read on raw channel */ return FALSE; } else { + /* If there is no callback, don't do anything. */ + if (channel->ch_callback == NULL) + return FALSE; + /* For a raw channel we don't know where the message ends, just get * everything. */ - msg = channel_get_all(idx); + msg = channel_get_all(ch_idx); argv[1].v_type = VAR_STRING; argv[1].vval.v_string = msg; } if (seq_nr > 0) { - cbq_T *cbhead = &channel->ch_cb_head; - cbq_T *cbitem = cbhead->next; + cbq_T *cbhead = &channel->ch_cb_head; + cbq_T *cbitem = cbhead->next; + int done = FALSE; /* invoke the one-time callback with the matching nr */ while (cbitem != cbhead) { if (cbitem->seq_nr == seq_nr) { - invoke_callback(idx, cbitem->callback, argv); + ch_log(ch_idx, "Invoking one-time callback\n"); + invoke_callback(ch_idx, cbitem->callback, argv); remove_cb_node(cbitem); + done = TRUE; break; } cbitem = cbitem->next; } + if (!done) + ch_log(ch_idx, "Dropping message without callback\n"); } else if (channel->ch_callback != NULL) { /* invoke the channel callback */ - invoke_callback(idx, channel->ch_callback, argv); + ch_log(ch_idx, "Invoking channel callback\n"); + invoke_callback(ch_idx, channel->ch_callback, argv); } - /* else: drop the message TODO: give error */ + else + ch_log(ch_idx, "Dropping message\n"); if (listtv != NULL) clear_tv(listtv); @@ -999,40 +1078,62 @@ may_invoke_callback(int idx) } /* - * Return TRUE when channel "idx" is open. - * Also returns FALSE or invalid "idx". + * Return TRUE when channel "ch_idx" is open for writing to. + * Also returns FALSE or invalid "ch_idx". */ int -channel_is_open(int idx) +channel_can_write_to(int ch_idx) { - return idx >= 0 && idx < channel_count && channels[idx].ch_fd >= 0; + return ch_idx >= 0 && ch_idx < channel_count + && (channels[ch_idx].ch_sock >= 0 +#ifdef CHANNEL_PIPES + || channels[ch_idx].ch_in >= 0 +#endif + ); } /* - * Close channel "idx". + * Return TRUE when channel "ch_idx" is open for reading or writing. + * Also returns FALSE or invalid "ch_idx". + */ + int +channel_is_open(int ch_idx) +{ + return ch_idx >= 0 && ch_idx < channel_count + && (channels[ch_idx].ch_sock >= 0 +#ifdef CHANNEL_PIPES + || channels[ch_idx].ch_in >= 0 + || channels[ch_idx].ch_out >= 0 + || channels[ch_idx].ch_err >= 0 +#endif + ); +} + +/* + * Close channel "ch_idx". * This does not trigger the close callback. */ void -channel_close(int idx) +channel_close(int ch_idx) { - channel_T *channel = &channels[idx]; + channel_T *channel = &channels[ch_idx]; jsonq_T *jhead; cbq_T *cbhead; - if (channel->ch_fd >= 0) + if (channel->ch_sock >= 0) { - sock_close(channel->ch_fd); - channel->ch_fd = -1; + sock_close(channel->ch_sock); + channel->ch_sock = -1; channel->ch_close_cb = NULL; #ifdef FEAT_GUI - channel_gui_unregister(idx); + channel_gui_unregister(ch_idx); #endif vim_free(channel->ch_callback); channel->ch_callback = NULL; channel->ch_timeout = 2000; - while (channel_peek(idx) != NULL) - vim_free(channel_get(idx)); + while (channel_peek(ch_idx) != NULL) + vim_free(channel_get(ch_idx)); cbhead = &channel->ch_cb_head; while (cbhead->next != cbhead) @@ -1045,17 +1146,34 @@ channel_close(int idx) remove_json_node(jhead->next); } } +#if defined(CHANNEL_PIPES) + if (channel->ch_in >= 0) + { + close(channel->ch_in); + channel->ch_in = -1; + } + if (channel->ch_out >= 0) + { + close(channel->ch_out); + channel->ch_out = -1; + } + if (channel->ch_err >= 0) + { + close(channel->ch_err); + channel->ch_err = -1; + } +#endif } /* - * Store "buf[len]" on channel "idx". + * Store "buf[len]" on channel "ch_idx". * Returns OK or FAIL. */ int -channel_save(int idx, char_u *buf, int len) +channel_save(int ch_idx, char_u *buf, int len) { readq_T *node; - readq_T *head = &channels[idx].ch_head; + readq_T *head = &channels[ch_idx].ch_head; node = (readq_T *)alloc(sizeof(readq_T)); if (node == NULL) @@ -1075,12 +1193,13 @@ channel_save(int idx, char_u *buf, int l head->prev->next = node; head->prev = node; - if (debugfd != NULL) + if (log_fd != NULL) { - fprintf(debugfd, "RECV on %d: ", idx); - if (fwrite(buf, len, 1, debugfd) != 1) + ch_log_lead("RECV ", ch_idx); + fprintf(log_fd, "'"); + if (fwrite(buf, len, 1, log_fd) != 1) return FAIL; - fprintf(debugfd, "\n"); + fprintf(log_fd, "'\n"); } return OK; } @@ -1090,9 +1209,9 @@ channel_save(int idx, char_u *buf, int l * Returns NULL if there is nothing. */ char_u * -channel_peek(int idx) +channel_peek(int ch_idx) { - readq_T *head = &channels[idx].ch_head; + readq_T *head = &channels[ch_idx].ch_head; if (head->next == head || head->next == NULL) return NULL; @@ -1100,12 +1219,12 @@ channel_peek(int idx) } /* - * Clear the read buffer on channel "idx". + * Clear the read buffer on channel "ch_idx". */ void -channel_clear(int idx) +channel_clear(int ch_idx) { - readq_T *head = &channels[idx].ch_head; + readq_T *head = &channels[ch_idx].ch_head; readq_T *node = head->next; readq_T *next; @@ -1136,13 +1255,15 @@ channel_clear(int idx) * Always returns OK for FEAT_GUI_W32. */ static int -channel_wait(int fd, int timeout) +channel_wait(int ch_idx, int fd, int timeout) { #if defined(HAVE_SELECT) && !defined(FEAT_GUI_W32) struct timeval tval; fd_set rfds; int ret; + if (timeout > 0) + ch_logn(ch_idx, "Waiting for %d msec\n", timeout); FD_ZERO(&rfds); FD_SET(fd, &rfds); tval.tv_sec = timeout / 1000; @@ -1155,17 +1276,25 @@ channel_wait(int fd, int timeout) continue; # endif if (ret <= 0) + { + ch_log(ch_idx, "Nothing to read\n"); return FAIL; + } break; } #else # ifdef HAVE_POLL struct pollfd fds; + if (timeout > 0) + ch_logn(ch_idx, "Waiting for %d msec\n", timeout); fds.fd = fd; fds.events = POLLIN; if (poll(&fds, 1, timeout) <= 0) + { + ch_log(ch_idx, "Nothing to read\n"); return FAIL; + } # endif #endif return OK; @@ -1183,22 +1312,43 @@ channel_get_id(void) } /* - * Read from channel "idx" for as long as there is something to read. + * Get the file descriptor to read from, either the socket or stdout. + */ + static int +get_read_fd(int ch_idx, int use_stderr) +{ + channel_T *channel = &channels[ch_idx]; + + if (channel->ch_sock >= 0) + return channel->ch_sock; +#if defined(CHANNEL_PIPES) + if (!use_stderr && channel->ch_out >= 0) + return channel->ch_out; + if (use_stderr && channel->ch_err >= 0) + return channel->ch_err; +#endif + ch_error(ch_idx, "channel_read() called while socket is closed\n"); + return -1; +} + +/* + * Read from channel "ch_idx" for as long as there is something to read. * The data is put in the read queue. */ void -channel_read(int idx) +channel_read(int ch_idx, int use_stderr, char *func) { + channel_T *channel = &channels[ch_idx]; static char_u *buf = NULL; int len = 0; int readlen = 0; - channel_T *channel = &channels[idx]; + int fd; + int use_socket = FALSE; - if (channel->ch_fd < 0) - { - CHLOG(idx, FALSE, "channel_read() called while socket is closed\n"); + fd = get_read_fd(ch_idx, use_stderr); + if (fd < 0) return; - } + use_socket = channel->ch_sock >= 0; /* Allocate a buffer to read into. */ if (buf == NULL) @@ -1213,20 +1363,23 @@ channel_read(int idx) * MAXMSGSIZE long. */ for (;;) { - if (channel_wait(channel->ch_fd, 0) == FAIL) + if (channel_wait(ch_idx, fd, 0) == FAIL) break; - len = sock_read(channel->ch_fd, buf, MAXMSGSIZE); + if (use_socket) + len = sock_read(fd, buf, MAXMSGSIZE); + else + len = read(fd, buf, MAXMSGSIZE); if (len <= 0) break; /* error or nothing more to read */ /* Store the read message in the queue. */ - channel_save(idx, buf, len); + channel_save(ch_idx, buf, len); readlen += len; if (len < MAXMSGSIZE) break; /* did read everything that's available */ } #ifdef FEAT_GUI_W32 - if (len == SOCKET_ERROR) + if (use_socket && len == SOCKET_ERROR) { /* For Win32 GUI channel_wait() always returns OK and we handle the * situation that there is nothing to read here. @@ -1249,44 +1402,62 @@ channel_read(int idx) * -> gui event loop or select loop * -> channel_read() */ - channel_save(idx, (char_u *)DETACH_MSG, (int)STRLEN(DETACH_MSG)); + ch_errors(ch_idx, "%s(): Cannot read\n", func); + channel_save(ch_idx, (char_u *)DETACH_MSG, (int)STRLEN(DETACH_MSG)); - channel_close(idx); - if (channel->ch_close_cb != NULL) - (*channel->ch_close_cb)(); + if (use_socket) + { + channel_close(ch_idx); + if (channel->ch_close_cb != NULL) + (*channel->ch_close_cb)(); + } +#if defined(CHANNEL_PIPES) + else + { + close(fd); + channel->ch_out = -1; + } +#endif if (len < 0) { - /* Todo: which channel? */ - CHERROR("%s(): cannot from channel\n", "channel_read"); + ch_error(ch_idx, "channel_read(): cannot read from channel\n"); PERROR(_("E896: read from channel")); } } #if defined(CH_HAS_GUI) && defined(FEAT_GUI_GTK) + /* signal the main loop that there is something to read */ if (CH_HAS_GUI && gtk_main_level() > 0) gtk_main_quit(); #endif } /* - * Read from raw channel "idx". Blocks until there is something to read or + * Read from raw channel "ch_idx". Blocks until there is something to read or * the timeout expires. * Returns what was read in allocated memory. * Returns NULL in case of error or timeout. */ char_u * -channel_read_block(int idx) +channel_read_block(int ch_idx) { - if (channel_peek(idx) == NULL) + ch_log(ch_idx, "Reading raw\n"); + if (channel_peek(ch_idx) == NULL) { + int fd = get_read_fd(ch_idx, FALSE); + + ch_log(ch_idx, "No readahead\n"); /* Wait for up to the channel timeout. */ - if (channel_wait(channels[idx].ch_fd, channels[idx].ch_timeout) == FAIL) + if (fd < 0 || channel_wait(ch_idx, fd, + channels[ch_idx].ch_timeout) == FAIL) return NULL; - channel_read(idx); + channel_read(ch_idx, FALSE, "channel_read_block"); } - return channel_get_all(idx); + /* TODO: only get the first message */ + ch_log(ch_idx, "Returning readahead\n"); + return channel_get_all(ch_idx); } /* @@ -1299,7 +1470,9 @@ channel_read_json_block(int ch_idx, int { int more; channel_T *channel = &channels[ch_idx]; + int fd; + ch_log(ch_idx, "Reading JSON\n"); channel->ch_block_id = id; for (;;) { @@ -1320,10 +1493,10 @@ channel_read_json_block(int ch_idx, int continue; /* Wait for up to the channel timeout. */ - if (channel->ch_fd < 0 || channel_wait(channel->ch_fd, - channel->ch_timeout) == FAIL) + fd = get_read_fd(ch_idx, FALSE); + if (fd < 0 || channel_wait(ch_idx, fd, channel->ch_timeout) == FAIL) break; - channel_read(ch_idx); + channel_read(ch_idx, FALSE, "channel_read_json_block"); } } channel->ch_block_id = 0; @@ -1336,45 +1509,75 @@ channel_read_json_block(int ch_idx, int * Returns -1 when the socket isn't found. */ int -channel_socket2idx(sock_T fd) +channel_fd2idx(sock_T fd) { int i; if (fd >= 0) for (i = 0; i < channel_count; ++i) - if (channels[i].ch_fd == fd) + if (channels[i].ch_sock == fd +# if defined(CHANNEL_PIPES) + || channels[i].ch_out == fd + || channels[i].ch_err == fd +# endif + ) return i; return -1; } # endif /* - * Write "buf" (NUL terminated string) to channel "idx". + * Write "buf" (NUL terminated string) to channel "ch_idx". * When "fun" is not NULL an error message might be given. * Return FAIL or OK. */ int -channel_send(int idx, char_u *buf, char *fun) +channel_send(int ch_idx, char_u *buf, char *fun) { - channel_T *channel = &channels[idx]; + channel_T *channel = &channels[ch_idx]; int len = (int)STRLEN(buf); + int res; + int fd; + int use_socket = FALSE; - if (channel->ch_fd < 0) + if (channel->ch_sock >= 0) + { + fd = channel->ch_sock; + use_socket = TRUE; + } +#if defined(CHANNEL_PIPES) + else if (channel->ch_in >= 0) + fd = channel->ch_in; +#endif + if (fd < 0) { if (!channel->ch_error && fun != NULL) { - CHERROR(" %s(): write while not connected\n", fun); + ch_errors(ch_idx, "%s(): write while not connected\n", fun); EMSG2("E630: %s(): write while not connected", fun); } channel->ch_error = TRUE; return FAIL; } - if (sock_write(channel->ch_fd, buf, len) != len) + if (log_fd != NULL) + { + ch_log_lead("SEND ", ch_idx); + fprintf(log_fd, "'"); + ignored = fwrite(buf, len, 1, log_fd); + fprintf(log_fd, "'\n"); + fflush(log_fd); + } + + if (use_socket) + res = sock_write(fd, buf, len); + else + res = write(fd, buf, len); + if (res != len) { if (!channel->ch_error && fun != NULL) { - CHERROR(" %s(): write failed\n", fun); + ch_errors(ch_idx, "%s(): write failed\n", fun); EMSG2("E631: %s(): write failed", fun); } channel->ch_error = TRUE; @@ -1399,15 +1602,39 @@ channel_poll_setup(int nfd_in, void *fds struct pollfd *fds = fds_in; for (i = 0; i < channel_count; ++i) - if (channels[i].ch_fd >= 0) + { + if (channels[i].ch_sock >= 0) { - channels[i].ch_idx = nfd; - fds[nfd].fd = channels[i].ch_fd; + channels[i].ch_sock_idx = nfd; + fds[nfd].fd = channels[i].ch_sock; fds[nfd].events = POLLIN; nfd++; } else - channels[i].ch_idx = -1; + channels[i].ch_sock_idx = -1; + +# ifdef CHANNEL_PIPES + if (channels[i].ch_out >= 0) + { + channels[i].ch_out_idx = nfd; + fds[nfd].fd = channels[i].ch_out; + fds[nfd].events = POLLIN; + nfd++; + } + else + channels[i].ch_out_idx = -1; + + if (channels[i].ch_err >= 0) + { + channels[i].ch_err_idx = nfd; + fds[nfd].fd = channels[i].ch_err; + fds[nfd].events = POLLIN; + nfd++; + } + else + channels[i].ch_err_idx = -1; +# endif + } return nfd; } @@ -1423,12 +1650,28 @@ channel_poll_check(int ret_in, void *fds struct pollfd *fds = fds_in; for (i = 0; i < channel_count; ++i) - if (ret > 0 && channels[i].ch_idx != -1 - && fds[channels[i].ch_idx].revents & POLLIN) + { + if (ret > 0 && channels[i].ch_sock_idx != -1 + && fds[channels[i].ch_sock_idx].revents & POLLIN) { - channel_read(i); + channel_read(i, FALSE, "channel_poll_check"); --ret; } +# ifdef CHANNEL_PIPES + if (ret > 0 && channels[i].ch_out_idx != -1 + && fds[channels[i].ch_out_idx].revents & POLLIN) + { + channel_read(i, FALSE, "channel_poll_check"); + --ret; + } + if (ret > 0 && channels[i].ch_err_idx != -1 + && fds[channels[i].ch_err_idx].revents & POLLIN) + { + channel_read(i, TRUE, "channel_poll_check"); + --ret; + } +# endif + } return ret; } @@ -1446,12 +1689,28 @@ channel_select_setup(int maxfd_in, void fd_set *rfds = rfds_in; for (i = 0; i < channel_count; ++i) - if (channels[i].ch_fd >= 0) + { + if (channels[i].ch_sock >= 0) + { + FD_SET(channels[i].ch_sock, rfds); + if (maxfd < channels[i].ch_sock) + maxfd = channels[i].ch_sock; + } +# ifdef CHANNEL_PIPES + if (channels[i].ch_out >= 0) { - FD_SET(channels[i].ch_fd, rfds); - if (maxfd < channels[i].ch_fd) - maxfd = channels[i].ch_fd; + FD_SET(channels[i].ch_out, rfds); + if (maxfd < channels[i].ch_out) + maxfd = channels[i].ch_out; } + if (channels[i].ch_err >= 0) + { + FD_SET(channels[i].ch_err, rfds); + if (maxfd < channels[i].ch_err) + maxfd = channels[i].ch_err; + } +# endif + } return maxfd; } @@ -1467,12 +1726,28 @@ channel_select_check(int ret_in, void *r fd_set *rfds = rfds_in; for (i = 0; i < channel_count; ++i) - if (ret > 0 && channels[i].ch_fd >= 0 - && FD_ISSET(channels[i].ch_fd, rfds)) + { + if (ret > 0 && channels[i].ch_sock >= 0 + && FD_ISSET(channels[i].ch_sock, rfds)) { - channel_read(i); + channel_read(i, FALSE, "channel_select_check"); --ret; } +# ifdef CHANNEL_PIPES + if (ret > 0 && channels[i].ch_out >= 0 + && FD_ISSET(channels[i].ch_out, rfds)) + { + channel_read(i, FALSE, "channel_select_check"); + --ret; + } + if (ret > 0 && channels[i].ch_err >= 0 + && FD_ISSET(channels[i].ch_err, rfds)) + { + channel_read(i, TRUE, "channel_select_check"); + --ret; + } +# endif + } return ret; } @@ -1528,15 +1803,15 @@ set_ref_in_channel(int copyID) } /* - * Return the mode of channel "idx". - * If "idx" is invalid returns MODE_JSON. + * Return the mode of channel "ch_idx". + * If "ch_idx" is invalid returns MODE_JSON. */ ch_mode_T -channel_get_mode(int idx) +channel_get_mode(int ch_idx) { - if (idx < 0 || idx >= channel_count) + if (ch_idx < 0 || ch_idx >= channel_count) return MODE_JSON; - return channels[idx].ch_mode; + return channels[ch_idx].ch_mode; } #endif /* FEAT_CHANNEL */
--- a/src/eval.c +++ b/src/eval.c @@ -503,8 +503,10 @@ static void f_call(typval_T *argvars, ty static void f_ceil(typval_T *argvars, typval_T *rettv); #endif #ifdef FEAT_CHANNEL +static void f_ch_close(typval_T *argvars, typval_T *rettv); +static void f_ch_logfile(typval_T *argvars, typval_T *rettv); static void f_ch_open(typval_T *argvars, typval_T *rettv); -static void f_ch_close(typval_T *argvars, typval_T *rettv); +static void f_ch_readraw(typval_T *argvars, typval_T *rettv); static void f_ch_sendexpr(typval_T *argvars, typval_T *rettv); static void f_ch_sendraw(typval_T *argvars, typval_T *rettv); #endif @@ -624,6 +626,7 @@ static void f_isdirectory(typval_T *argv static void f_islocked(typval_T *argvars, typval_T *rettv); static void f_items(typval_T *argvars, typval_T *rettv); #ifdef FEAT_JOB +static void f_job_getchannel(typval_T *argvars, typval_T *rettv); static void f_job_start(typval_T *argvars, typval_T *rettv); static void f_job_stop(typval_T *argvars, typval_T *rettv); static void f_job_status(typval_T *argvars, typval_T *rettv); @@ -7720,6 +7723,8 @@ failret: static void job_free(job_T *job) { + if (job->jv_channel >= 0) + channel_close(job->jv_channel); mch_clear_job(job); vim_free(job); } @@ -8083,7 +8088,9 @@ static struct fst #endif #ifdef FEAT_CHANNEL {"ch_close", 1, 1, f_ch_close}, + {"ch_logfile", 1, 2, f_ch_logfile}, {"ch_open", 1, 2, f_ch_open}, + {"ch_readraw", 1, 2, f_ch_readraw}, {"ch_sendexpr", 2, 3, f_ch_sendexpr}, {"ch_sendraw", 2, 3, f_ch_sendraw}, #endif @@ -8207,6 +8214,7 @@ static struct fst {"islocked", 1, 1, f_islocked}, {"items", 1, 1, f_items}, #ifdef FEAT_JOB + {"job_getchannel", 1, 1, f_job_getchannel}, {"job_start", 1, 2, f_job_start}, {"job_status", 1, 1, f_job_status}, {"job_stop", 1, 2, f_job_stop}, @@ -9788,7 +9796,7 @@ get_channel_arg(typval_T *tv) } ch_idx = tv->vval.v_number; - if (!channel_is_open(ch_idx)) + if (!channel_can_write_to(ch_idx)) { EMSGN(_("E906: not an open channel"), ch_idx); return -1; @@ -9825,6 +9833,32 @@ get_callback(typval_T *arg) } /* + * "ch_logfile()" function + */ + static void +f_ch_logfile(typval_T *argvars, typval_T *rettv UNUSED) +{ + char_u *fname; + char_u *opt = (char_u *)""; + char_u buf[NUMBUFLEN]; + FILE *file = NULL; + + fname = get_tv_string(&argvars[0]); + if (argvars[1].v_type == VAR_STRING) + opt = get_tv_string_buf(&argvars[1], buf); + if (*fname != NUL) + { + file = fopen((char *)fname, *opt == 'w' ? "w" : "a"); + if (file == NULL) + { + EMSG2(_(e_notopen), fname); + return; + } + } + ch_logfile(file); +} + +/* * "ch_open()" function */ static void @@ -9914,6 +9948,27 @@ f_ch_open(typval_T *argvars, typval_T *r } /* + * "ch_readraw()" function + */ + static void +f_ch_readraw(typval_T *argvars, typval_T *rettv) +{ + int ch_idx; + + /* return an empty string by default */ + rettv->v_type = VAR_STRING; + rettv->vval.v_string = NULL; + + ch_idx = get_channel_arg(&argvars[0]); + if (ch_idx < 0) + { + EMSG(_(e_invarg)); + return; + } + rettv->vval.v_string = channel_read_block(ch_idx); +} + +/* * common for "sendexpr()" and "sendraw()" * Returns the channel index if the caller should read the response. * Otherwise returns -1. @@ -14300,6 +14355,23 @@ f_items(typval_T *argvars, typval_T *ret #ifdef FEAT_JOB /* + * "job_getchannel()" function + */ + static void +f_job_getchannel(typval_T *argvars, typval_T *rettv) +{ + if (argvars[0].v_type != VAR_JOB) + EMSG(_(e_invarg)); + else + { + job_T *job = argvars[0].vval.v_job; + + rettv->v_type = VAR_NUMBER; + rettv->vval.v_number = job->jv_channel; + } +} + +/* * "job_start()" function */ static void @@ -14401,7 +14473,7 @@ theend: * "job_status()" function */ static void -f_job_status(typval_T *argvars UNUSED, typval_T *rettv UNUSED) +f_job_status(typval_T *argvars, typval_T *rettv) { char *result;
--- a/src/gui_w48.c +++ b/src/gui_w48.c @@ -1780,10 +1780,10 @@ process_message(void) #ifdef FEAT_CHANNEL if (msg.message == WM_NETBEANS) { - int channel_idx = channel_socket2idx((sock_T)msg.wParam); + int channel_idx = channel_fd2idx((sock_T)msg.wParam); if (channel_idx >= 0) - channel_read(channel_idx); + channel_read(channel_idx, FALSE, "process_message"); return; } #endif
--- a/src/os_unix.c +++ b/src/os_unix.c @@ -3984,6 +3984,42 @@ mch_parse_cmd(char_u *cmd, int use_shcf, } #endif +#if !defined(USE_SYSTEM) || defined(FEAT_JOB) + static void +set_child_environment(void) +{ +# ifdef HAVE_SETENV + char envbuf[50]; +# else + static char envbuf_Rows[20]; + static char envbuf_Columns[20]; +# endif + + /* Simulate to have a dumb terminal (for now) */ +# ifdef HAVE_SETENV + setenv("TERM", "dumb", 1); + sprintf((char *)envbuf, "%ld", Rows); + setenv("ROWS", (char *)envbuf, 1); + sprintf((char *)envbuf, "%ld", Rows); + setenv("LINES", (char *)envbuf, 1); + sprintf((char *)envbuf, "%ld", Columns); + setenv("COLUMNS", (char *)envbuf, 1); +# else + /* + * Putenv does not copy the string, it has to remain valid. + * Use a static array to avoid losing allocated memory. + */ + putenv("TERM=dumb"); + sprintf(envbuf_Rows, "ROWS=%ld", Rows); + putenv(envbuf_Rows); + sprintf(envbuf_Rows, "LINES=%ld", Rows); + putenv(envbuf_Rows); + sprintf(envbuf_Columns, "COLUMNS=%ld", Columns); + putenv(envbuf_Columns); +# endif +} +#endif + int mch_call_shell( char_u *cmd, @@ -4134,12 +4170,6 @@ mch_call_shell( int fd_toshell[2]; /* for pipes */ int fd_fromshell[2]; int pipe_error = FALSE; -# ifdef HAVE_SETENV - char envbuf[50]; -# else - static char envbuf_Rows[20]; - static char envbuf_Columns[20]; -# endif int did_settmode = FALSE; /* settmode(TMODE_RAW) called */ newcmd = vim_strsave(p_sh); @@ -4349,28 +4379,7 @@ mch_call_shell( # endif } # endif - /* Simulate to have a dumb terminal (for now) */ -# ifdef HAVE_SETENV - setenv("TERM", "dumb", 1); - sprintf((char *)envbuf, "%ld", Rows); - setenv("ROWS", (char *)envbuf, 1); - sprintf((char *)envbuf, "%ld", Rows); - setenv("LINES", (char *)envbuf, 1); - sprintf((char *)envbuf, "%ld", Columns); - setenv("COLUMNS", (char *)envbuf, 1); -# else - /* - * Putenv does not copy the string, it has to remain valid. - * Use a static array to avoid losing allocated memory. - */ - putenv("TERM=dumb"); - sprintf(envbuf_Rows, "ROWS=%ld", Rows); - putenv(envbuf_Rows); - sprintf(envbuf_Rows, "LINES=%ld", Rows); - putenv(envbuf_Rows); - sprintf(envbuf_Columns, "COLUMNS=%ld", Columns); - putenv(envbuf_Columns); -# endif + set_child_environment(); /* * stderr is only redirected when using the GUI, so that a @@ -5030,13 +5039,34 @@ error: void mch_start_job(char **argv, job_T *job) { - pid_t pid = fork(); - - if (pid == -1) /* maybe we should use vfork() */ - { - job->jv_status = JOB_FAILED; - } - else if (pid == 0) + pid_t pid; + int fd_in[2]; /* for stdin */ + int fd_out[2]; /* for stdout */ + int fd_err[2]; /* for stderr */ + int ch_idx; + + /* default is to fail */ + job->jv_status = JOB_FAILED; + fd_in[0] = -1; + fd_out[0] = -1; + fd_err[0] = -1; + + /* Open pipes for stdin, stdout, stderr. */ + if ((pipe(fd_in) < 0) || (pipe(fd_out) < 0) ||(pipe(fd_err) < 0)) + goto failed; + + ch_idx = add_channel(); + if (ch_idx < 0) + goto failed; + + pid = fork(); /* maybe we should use vfork() */ + if (pid == -1) + { + /* failed to fork */ + goto failed; + } + + if (pid == 0) { /* child */ reset_signals(); /* handle signals normally */ @@ -5048,17 +5078,62 @@ mch_start_job(char **argv, job_T *job) (void)setsid(); # endif + set_child_environment(); + + /* set up stdin for the child */ + close(fd_in[1]); + close(0); + ignored = dup(fd_in[0]); + close(fd_in[0]); + + /* set up stdout for the child */ + close(fd_out[0]); + close(1); + ignored = dup(fd_out[1]); + close(fd_out[1]); + + /* set up stderr for the child */ + close(fd_err[0]); + close(2); + ignored = dup(fd_err[1]); + close(fd_err[1]); + /* See above for type of argv. */ execvp(argv[0], argv); perror("executing job failed"); _exit(EXEC_FAILED); /* exec failed, return failure code */ } - else - { - /* parent */ - job->jv_pid = pid; - job->jv_status = JOB_STARTED; + + /* parent */ + job->jv_pid = pid; + job->jv_status = JOB_STARTED; + job->jv_channel = ch_idx; + + /* child stdin, stdout and stderr */ + close(fd_in[0]); + close(fd_out[1]); + close(fd_err[1]); + channel_set_pipes(ch_idx, fd_in[1], fd_out[0], fd_err[0]); + channel_set_job(ch_idx, job); + + return; + +failed: + if (fd_in[0] >= 0) + { + close(fd_in[0]); + close(fd_in[1]); + } + if (fd_out[0] >= 0) + { + close(fd_out[0]); + close(fd_out[1]); + } + if (fd_err[0] >= 0) + { + close(fd_err[0]); + close(fd_err[1]); } } @@ -5104,8 +5179,8 @@ mch_job_status(job_T *job) int mch_stop_job(job_T *job, char_u *how) { - int sig = -1; - pid_t job_pid; + int sig = -1; + pid_t job_pid; if (STRCMP(how, "hup") == 0) sig = SIGHUP;
--- a/src/proto/channel.pro +++ b/src/proto/channel.pro @@ -1,22 +1,27 @@ /* channel.c */ +void ch_logfile(FILE *file); +int add_channel(void); void channel_gui_register_all(void); int channel_open(char *hostname, int port_in, int waittime, void (*close_cb)(void)); +void channel_set_pipes(int idx, int in, int out, int err); +void channel_set_job(int idx, job_T *job); void channel_set_json_mode(int idx, ch_mode_T ch_mode); void channel_set_timeout(int idx, int timeout); void channel_set_callback(int idx, char_u *callback); void channel_set_req_callback(int idx, char_u *callback, int id); char_u *channel_get(int idx); int channel_collapse(int idx); +int channel_can_write_to(int idx); int channel_is_open(int idx); void channel_close(int idx); int channel_save(int idx, char_u *buf, int len); char_u *channel_peek(int idx); void channel_clear(int idx); int channel_get_id(void); -void channel_read(int idx); +void channel_read(int idx, int use_stderr, char *func); char_u *channel_read_block(int idx); int channel_read_json_block(int ch_idx, int id, typval_T **rettv); -int channel_socket2idx(sock_T fd); +int channel_fd2idx(sock_T fd); int channel_send(int idx, char_u *buf, char *fun); int channel_poll_setup(int nfd_in, void *fds_in); int channel_poll_check(int ret_in, void *fds_in);
--- a/src/structs.h +++ b/src/structs.h @@ -1110,7 +1110,12 @@ typedef double float_T; typedef struct listvar_S list_T; typedef struct dictvar_S dict_T; + typedef struct jobvar_S job_T; +typedef struct readq_S readq_T; +typedef struct jsonq_S jsonq_T; +typedef struct cbq_S cbq_T; +typedef struct channel_S channel_T; typedef enum { @@ -1255,8 +1260,92 @@ struct jobvar_S jobstatus_T jv_status; int jv_refcount; /* reference count */ + int jv_channel; /* channel for I/O */ }; +/* + * Structures to hold info about a Channel. + */ +struct readq_S +{ + char_u *buffer; + readq_T *next; + readq_T *prev; +}; + +struct jsonq_S +{ + typval_T *value; + jsonq_T *next; + jsonq_T *prev; +}; + +struct cbq_S +{ + char_u *callback; + int seq_nr; + cbq_T *next; + cbq_T *prev; +}; + +/* mode for a channel */ +typedef enum +{ + MODE_RAW = 0, + MODE_JSON, + MODE_JS +} ch_mode_T; + +struct channel_S { + sock_T ch_sock; /* the socket, -1 for a closed channel */ + +#ifdef UNIX +# define CHANNEL_PIPES + int ch_in; /* stdin of the job, -1 if not used */ + int ch_out; /* stdout of the job, -1 if not used */ + int ch_err; /* stderr of the job, -1 if not used */ + +# if defined(UNIX) && !defined(HAVE_SELECT) + int ch_sock_idx; /* used by channel_poll_setup() */ + int ch_in_idx; /* used by channel_poll_setup() */ + int ch_out_idx; /* used by channel_poll_setup() */ + int ch_err_idx; /* used by channel_poll_setup() */ +# endif +#endif + + readq_T ch_head; /* dummy node, header for circular queue */ + + int ch_error; /* When TRUE an error was reported. Avoids + * giving pages full of error messages when + * the other side has exited, only mention the + * first error until the connection works + * again. */ +#ifdef FEAT_GUI_X11 + XtInputId ch_inputHandler; /* Cookie for input */ +#endif +#ifdef FEAT_GUI_GTK + gint ch_inputHandler; /* Cookie for input */ +#endif +#ifdef WIN32 + int ch_inputHandler; /* simply ret.value of WSAAsyncSelect() */ +#endif + + void (*ch_close_cb)(void); /* callback for when channel is closed */ + + int ch_block_id; /* ID that channel_read_json_block() is + waiting for */ + char_u *ch_callback; /* function to call when a msg is not handled */ + cbq_T ch_cb_head; /* dummy node for pre-request callbacks */ + + ch_mode_T ch_mode; + jsonq_T ch_json_head; /* dummy node, header for circular queue */ + + int ch_timeout; /* request timeout in msec */ + + job_T *ch_job; /* job that uses this channel */ +}; + + /* structure used for explicit stack while garbage collecting hash tables */ typedef struct ht_stack_S { @@ -2729,11 +2818,3 @@ struct js_reader void *js_cookie; /* can be used by js_fill */ }; typedef struct js_reader js_read_T; - -/* mode for a channel */ -typedef enum -{ - MODE_RAW = 0, - MODE_JSON, - MODE_JS -} ch_mode_T;
--- a/src/testdir/test_channel.vim +++ b/src/testdir/test_channel.vim @@ -273,3 +273,20 @@ func Test_connect_waittime() call assert_true(reltimefloat(elapsed) < (has('unix') ? 1.0 : 3.0)) endif endfunc + +func Test_pipe() + if !has('job') || !has('unix') + return + endif + let job = job_start("python test_channel_pipe.py") + call assert_equal("run", job_status(job)) + try + let handle = job_getchannel(job) + call ch_sendraw(handle, "echo something\n", 0) + call assert_equal("something\n", ch_readraw(handle)) + let reply = ch_sendraw(handle, "quit\n") + call assert_equal("Goodbye!\n", reply) + finally + call job_stop(job) + endtry +endfunc
new file mode 100644 --- /dev/null +++ b/src/testdir/test_channel_pipe.py @@ -0,0 +1,24 @@ +#!/usr/bin/python +# +# Server that will communicate over stdin/stderr +# +# This requires Python 2.6 or later. + +from __future__ import print_function +import sys + +if __name__ == "__main__": + + if len(sys.argv) > 1: + print(sys.argv[1]) + + while True: + typed = sys.stdin.readline() + if typed.startswith("quit"): + print("Goodbye!") + sys.stdout.flush() + break + if typed.startswith("echo"): + print(typed[5:-1]) + sys.stdout.flush() +