vim-patch:7.4.285

Problem:    When 'relativenumber' is set and deleting lines or undoing that,
            line numbers are not always updated. (Robert Arkwright)
Solution:   (Christian Brabandt)

https://code.google.com/p/vim/source/detail?r=5cb1828fd0056de3c166e71fbafc67a74c57d7b1
memory: add xstrlcpy

Less "blow a hole in your foot" than strncpy. As also indicated by coverity.
Implementation inspired by the linux kernel (very similar to OSX's Libc
implementation as well).
coverity: fix BUFFER_SIZE_WARNING with str{n,l}cpy

Relates to issue #760

These coverity warnings are of the form:

>>>     CID 62602:  Buffer not null terminated  (BUFFER_SIZE_WARNING)
>>>     Calling strncpy with a maximum size argument of 256 bytes...

This is caused by strncpy not alway NULL-terminated the destination buffer
(for example in the case where strlen(src) >= size(dst)). It's better to
replace that with (x)strlcpy, which always NULL-terminates.

Most of these are related to the set_api_error macro, which uses strncpy.
The error struct is used (for example) in msgpack_rpc_error, where strlen is
executed on it, so it needs to be NULL-terminated. (x)strlcpy, unlike
strncpy, always NULL-terminates the destination buffer.

Relevant parts of the coverity report:

*** CID 62602:  Buffer not null terminated  (BUFFER_SIZE_WARNING)
/src/nvim/api/vim.c: 236 in vim_set_current_buffer()
230         if (try_end(err)) {
231           return;
232         }
233
234         char msg[256];
235         snprintf(msg, sizeof(msg),
              "failed to switch to buffer %d", (int)buffer);
>>>     CID 62602:  Buffer not null terminated  (BUFFER_SIZE_WARNING)
>>>     Calling strncpy with a maximum size argument of 256 bytes on
>>>     destination array "err->msg" of size 256 bytes might leave the
>>>     destination string unterminated.
236         set_api_error(msg, err);
237         return;
238       }
239
240       try_end(err);
241     }

*** CID 62603:  Buffer not null terminated  (BUFFER_SIZE_WARNING)
/src/nvim/api/private/helpers.c: 70 in try_end()
64       } else if (msg_list != NULL && *msg_list != NULL) {
65         int should_free;
66         char *msg = (char *)get_exception_string(*msg_list,
67                                                  ET_ERROR,
68                                                  NULL,
69                                                  &should_free);
>>>     CID 62603:  Buffer not null terminated  (BUFFER_SIZE_WARNING)
>>>     Calling strncpy with a maximum size argument of 256 bytes on
>>>     destination array "err->msg" of size 256 bytes might leave the
>>>     destination string unterminated.
70         strncpy(err->msg, msg, sizeof(err->msg));
71         err->set = true;
72         free_global_msglist();
73
74         if (should_free) {
75           free(msg);
/src/nvim/api/private/helpers.c: 78 in try_end()
72         free_global_msglist();
73
74         if (should_free) {
75           free(msg);
76         }
77       } else if (did_throw) {
>>>     CID 62603:  Buffer not null terminated  (BUFFER_SIZE_WARNING)
>>>     Calling strncpy with a maximum size argument of 256 bytes on
>>>     destination array "err->msg" of size 256 bytes might leave the
>>>     destination string unterminated.
78         set_api_error((char *)current_exception->value, err);
79       }
80
81       return err->set;
82     }
83

*** CID 62604:  Buffer not null terminated  (BUFFER_SIZE_WARNING)
/src/nvim/api/private/helpers.c: 592 in set_option_value_err()
586                                              opt_flags)))
587       {
588         if (try_end(err)) {
589           return;
590         }
591
>>>     CID 62604:  Buffer not null terminated  (BUFFER_SIZE_WARNING)
>>>     Calling strncpy with a maximum size argument of 256 bytes on
>>>     destination array "err->msg" of size 256 bytes might leave the
>>>     destination string unterminated.
592         set_api_error(errmsg, err);
593       }

*** CID 62605:  Buffer not null terminated  (BUFFER_SIZE_WARNING)
/src/nvim/os/server.c: 114 in server_start()
108       if (addr_len > sizeof(ip) - 1) {
109         // Maximum length of a ip address buffer is 15(eg: 255.255.255.255)
110         addr_len = sizeof(ip);
111       }
112
113       // Extract the address part
>>>     CID 62605:  Buffer not null terminated  (BUFFER_SIZE_WARNING)
>>>     Calling strncpy with a maximum size argument of 16 bytes on
>>>     destination array "ip" of size 16 bytes might leave the destination
>>>     string unterminated.
114       strncpy(ip, addr, addr_len);
115
116       int port = NEOVIM_DEFAULT_TCP_PORT;
117
118       if (*ip_end == ':') {
119         char *port_end;
/src/nvim/os/server.c: 88 in server_start()
82
83     void server_start(char *endpoint, ChannelProtocol prot)
84     {
85       char addr[ADDRESS_MAX_SIZE];
86
87       // Trim to `ADDRESS_MAX_SIZE`
>>>     CID 62605:  Buffer not null terminated  (BUFFER_SIZE_WARNING)
>>>     Calling strncpy with a maximum size argument of 256 bytes on
>>>     destination array "addr" of size 256 bytes might leave the
>>>     destination string unterminated.
88       strncpy(addr, endpoint, sizeof(addr));
89
90       // Check if the server already exists
91       if (map_has(cstr_t)(servers, addr)) {
92         EMSG2("Already listening on %s", addr);
93         return;

*** CID 62606:  Buffer not null terminated  (BUFFER_SIZE_WARNING)
/src/nvim/os/server.c: 186 in server_stop()
180     void server_stop(char *endpoint)
181     {
182       Server *server;
183       char addr[ADDRESS_MAX_SIZE];
184
185       // Trim to `ADDRESS_MAX_SIZE`
>>>     CID 62606:  Buffer not null terminated  (BUFFER_SIZE_WARNING)
>>>     Calling strncpy with a maximum size argument of 256 bytes on
>>>     destination array "addr" of size 256 bytes might leave the
>>>     destination string unterminated.
187
188       if ((server = map_get(cstr_t)(servers, addr)) == NULL) {
189         EMSG2("Not listening on %s", addr);
190         return;
191       }
Merge pull request #761 'fix a few strncpy calls by using xstrlcpy'
Dead code: Remove unused vimscript functions(from FEAT_CLIENTSERVER)
API: Refactor: Duplicate/free string arguments coming from msgpack

When receiving strings *from* msgpack, we don't need to duplicate/free since
the data only lives in the msgpack parse buffer until the end of the call.

But in order to reuse `msgpack_rpc_free_object` when sending event data(which is
sent *to* msgpack), Strings must be freed, which means they must also be
allocated separately.
API: Refactor: Close/free channels when their streams reach EOF
API: Events: Return channel id from the API discover request

This refactors msgapck_rpc_{dipatch,call} to receive the channel id as
argument. Now the discovery request returns the [id, metadata] array.
API: Events: Implement channel_send_event and vimscript wrapper

This function can be used to send arbitrary objects via the API channel back to
connected clients, identified by channel id.
Build: Add 'nonnull' attributes to msgpack_rpc functions
Build: Add api/{helpers,handle}.c to CONV_SRCS
Build: Add more files to clint-files.txt and fix errors
Build: Enable valgrind's --leak-check when testing the API
API: Bugfix: Remove memory leak from set_option_to
API: Bugfix: Remove memory leak from buffer_set_slice
API: Bugfix: Remove memory leak from buffer_set_name
API: Bugfix: Remove memory leak from buffer_get_line
Merge branch 'api-events'
Merge pull request #749 from oni-link/vim-patch-7-4-285

vim-patch:7.4.285
Refactor: Remove support for multiple protocols

This removes the boilerplate code supporting more than one RPC protocol as it
was becoming hard to maintain and we probably won't ever need it.