static bool try_command(json_t *cmd, int timeout)
{
w_stm_t client = NULL;
w_jbuffer_t buffer;
w_jbuffer_t output_pdu_buffer;
int err;
client = w_stm_connect(sock_name, timeout * 1000);
if (client == NULL) {
return false;
}
if (!cmd) {
w_stm_close(client);
return true;
}
w_json_buffer_init(&buffer);
// Send command
if (!w_ser_write_pdu(server_pdu, &buffer, client, cmd)) {
err = errno;
w_log(W_LOG_ERR, "error sending PDU to server\n");
w_json_buffer_free(&buffer);
w_stm_close(client);
errno = err;
return false;
}
w_json_buffer_reset(&buffer);
w_json_buffer_init(&output_pdu_buffer);
do {
if (!w_json_buffer_passthru(
&buffer, output_pdu, &output_pdu_buffer, client)) {
err = errno;
w_json_buffer_free(&buffer);
w_json_buffer_free(&output_pdu_buffer);
w_stm_close(client);
errno = err;
return false;
}
} while (persistent);
w_json_buffer_free(&buffer);
w_json_buffer_free(&output_pdu_buffer);
w_stm_close(client);
return true;
}
static struct watchman_client *make_new_client(w_stm_t stm) {
struct watchman_client *client;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
client = calloc(1, derived_client_size);
if (!client) {
pthread_attr_destroy(&attr);
return NULL;
}
client->stm = stm;
w_log(W_LOG_DBG, "accepted client:stm=%p\n", client->stm);
if (!w_json_buffer_init(&client->reader)) {
// FIXME: error handling
}
if (!w_json_buffer_init(&client->writer)) {
// FIXME: error handling
}
client->ping = w_event_make();
if (!client->ping) {
// FIXME: error handling
}
derived_client_ctor(client);
pthread_mutex_lock(&w_client_lock);
w_ht_set(clients, w_ht_ptr_val(client), w_ht_ptr_val(client));
pthread_mutex_unlock(&w_client_lock);
// Start a thread for the client.
// We used to use libevent for this, but we have
// a low volume of concurrent clients and the json
// parse/encode APIs are not easily used in a non-blocking
// server architecture.
if (pthread_create(&client->thread_handle, &attr, client_thread, client)) {
// It didn't work out, sorry!
pthread_mutex_lock(&w_client_lock);
w_ht_del(clients, w_ht_ptr_val(client));
pthread_mutex_unlock(&w_client_lock);
client_delete(client);
}
pthread_attr_destroy(&attr);
return client;
}
bool w_state_save(void)
{
json_t *state;
w_jbuffer_t buffer;
int fd = -1;
char tmpname[WATCHMAN_NAME_MAX];
bool result = false;
if (dont_save_state) {
return true;
}
pthread_mutex_lock(&state_lock);
state = json_object();
if (!w_json_buffer_init(&buffer)) {
w_log(W_LOG_ERR, "save_state: failed to init json buffer\n");
goto out;
}
snprintf(tmpname, sizeof(tmpname), "%sXXXXXX",
watchman_state_file);
fd = w_mkstemp(tmpname);
if (fd == -1) {
w_log(W_LOG_ERR, "save_state: unable to create temporary file: %s\n",
strerror(errno));
goto out;
}
json_object_set_new(state, "version", json_string(PACKAGE_VERSION));
/* now ask the different subsystems to fill out the state */
if (!w_root_save_state(state)) {
goto out;
}
/* we've prepared what we're going to save, so write it out */
w_json_buffer_write(&buffer, fd, state, JSON_INDENT(4));
/* atomically replace the old contents */
result = rename(tmpname, watchman_state_file) == 0;
out:
if (state) {
json_decref(state);
}
w_json_buffer_free(&buffer);
if (fd != -1) {
if (!result) {
// If we didn't succeed, remove our temporary file
unlink(tmpname);
}
close(fd);
}
pthread_mutex_unlock(&state_lock);
return result;
}
static json_t *build_command(int argc, char **argv)
{
json_t *cmd;
int i;
// Read blob from stdin
if (json_input_arg) {
json_error_t err;
w_jbuffer_t buf;
memset(&err, 0, sizeof(err));
w_json_buffer_init(&buf);
cmd = w_json_buffer_next(&buf, w_stm_stdin(), &err);
if (buf.pdu_type == is_bser) {
// If they used bser for the input, select bser for output
// unless they explicitly requested something else
if (!server_encoding) {
server_pdu = is_bser;
}
if (!output_encoding) {
output_pdu = is_bser;
}
} else if (buf.pdu_type == is_bser_v2) {
// If they used bser v2 for the input, select bser v2 for output
// unless they explicitly requested something else
if (!server_encoding) {
server_pdu = is_bser_v2;
}
if (!output_encoding) {
output_pdu = is_bser_v2;
}
}
w_json_buffer_free(&buf);
if (cmd == NULL) {
fprintf(stderr, "failed to parse command from stdin: %s\n",
err.text);
exit(1);
}
return cmd;
}
// Special case: no arguments means that we just want
// to verify that the service is up, starting it if
// needed
if (argc == 0) {
return NULL;
}
cmd = json_array();
for (i = 0; i < argc; i++) {
json_array_append_new(cmd, json_string(argv[i]));
}
return cmd;
}
static bool try_command(json_t *cmd, int timeout)
{
int fd;
int res;
int tries;
w_jbuffer_t buffer;
fd = socket(PF_LOCAL, SOCK_STREAM, 0);
if (fd == -1) {
perror("socket");
return false;
}
tries = 0;
do {
res = connect(fd, (struct sockaddr*)&un, sizeof(un));
if (res == 0) {
break;
}
if (timeout && tries < timeout && should_start(errno)) {
// Wait for socket to come up
sleep(1);
continue;
}
} while (++tries < timeout);
if (res) {
close(fd);
return false;
}
if (!cmd) {
close(fd);
return true;
}
w_json_buffer_init(&buffer);
// Send command
w_json_buffer_write(&buffer, fd, cmd, JSON_COMPACT);
do {
if (!read_response(&buffer, fd)) {
w_json_buffer_free(&buffer);
close(fd);
return false;
}
} while (persistent);
w_json_buffer_free(&buffer);
close(fd);
return true;
}
void preprocess_command(json_t *args, enum w_pdu_type output_pdu)
{
char *errmsg = NULL;
struct watchman_command_handler_def *def;
def = lookup(args, &errmsg, 0);
if (!def && !errmsg) {
// Nothing known about it, pass the command on anyway for forwards
// compatibility
return;
}
if (!errmsg && def->cli_validate) {
def->cli_validate(args, &errmsg);
}
if (errmsg) {
w_jbuffer_t jr;
json_t *err = json_pack(
"{s:s, s:s, s:b}",
"error", errmsg,
"version", PACKAGE_VERSION,
"cli_validated", true
);
w_json_buffer_init(&jr);
w_ser_write_pdu(output_pdu, &jr, w_stm_stdout(), err);
json_decref(err);
w_json_buffer_free(&jr);
free(errmsg);
exit(1);
}
}
bool w_start_listener(const char *path)
{
struct sockaddr_un un;
pthread_t thr;
pthread_attr_t attr;
pthread_mutexattr_t mattr;
struct sigaction sa;
sigset_t sigset;
#ifdef HAVE_LIBGIMLI_H
volatile struct gimli_heartbeat *hb = NULL;
#endif
struct timeval tv;
void *ignored;
int n_clients = 0;
listener_thread = pthread_self();
pthread_mutexattr_init(&mattr);
pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&w_client_lock, &mattr);
pthread_mutexattr_destroy(&mattr);
#ifdef HAVE_LIBGIMLI_H
hb = gimli_heartbeat_attach();
#endif
#if defined(HAVE_KQUEUE) || defined(HAVE_FSEVENTS)
{
struct rlimit limit;
int mib[2] = { CTL_KERN,
#ifdef KERN_MAXFILESPERPROC
KERN_MAXFILESPERPROC
#else
KERN_MAXFILES
#endif
};
int maxperproc;
size_t len;
len = sizeof(maxperproc);
sysctl(mib, 2, &maxperproc, &len, NULL, 0);
getrlimit(RLIMIT_NOFILE, &limit);
w_log(W_LOG_ERR, "file limit is %" PRIu64
" kern.maxfilesperproc=%i\n",
limit.rlim_cur, maxperproc);
if (limit.rlim_cur != RLIM_INFINITY &&
maxperproc > 0 &&
limit.rlim_cur < (rlim_t)maxperproc) {
limit.rlim_cur = maxperproc;
if (setrlimit(RLIMIT_NOFILE, &limit)) {
w_log(W_LOG_ERR,
"failed to raise limit to %" PRIu64 " (%s).\n",
limit.rlim_cur,
strerror(errno));
} else {
w_log(W_LOG_ERR,
"raised file limit to %" PRIu64 "\n",
limit.rlim_cur);
}
}
getrlimit(RLIMIT_NOFILE, &limit);
#ifndef HAVE_FSEVENTS
if (limit.rlim_cur < 10240) {
w_log(W_LOG_ERR,
"Your file descriptor limit is very low (%" PRIu64 "), "
"please consult the watchman docs on raising the limits\n",
limit.rlim_cur);
}
#endif
}
#endif
proc_pid = (int)getpid();
if (gettimeofday(&tv, NULL) == -1) {
w_log(W_LOG_ERR, "gettimeofday failed: %s\n", strerror(errno));
return false;
}
proc_start_time = (uint64_t)tv.tv_sec;
if (strlen(path) >= sizeof(un.sun_path) - 1) {
w_log(W_LOG_ERR, "%s: path is too long\n",
path);
return false;
}
signal(SIGPIPE, SIG_IGN);
/* allow SIGUSR1 and SIGCHLD to wake up a blocked thread, without restarting
* syscalls */
memset(&sa, 0, sizeof(sa));
sa.sa_handler = wakeme;
sa.sa_flags = 0;
sigaction(SIGUSR1, &sa, NULL);
sigaction(SIGCHLD, &sa, NULL);
// Block SIGCHLD everywhere
sigemptyset(&sigset);
sigaddset(&sigset, SIGCHLD);
sigprocmask(SIG_BLOCK, &sigset, NULL);
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
listener_fd = socket(PF_LOCAL, SOCK_STREAM, 0);
if (listener_fd == -1) {
w_log(W_LOG_ERR, "socket: %s\n",
strerror(errno));
return false;
}
un.sun_family = PF_LOCAL;
strcpy(un.sun_path, path);
unlink(path);
if (bind(listener_fd, (struct sockaddr*)&un, sizeof(un)) != 0) {
w_log(W_LOG_ERR, "bind(%s): %s\n",
path, strerror(errno));
close(listener_fd);
return false;
}
if (listen(listener_fd, 200) != 0) {
w_log(W_LOG_ERR, "listen(%s): %s\n",
path, strerror(errno));
close(listener_fd);
return false;
}
w_set_cloexec(listener_fd);
if (pthread_create(&reaper_thread, NULL, child_reaper, NULL)) {
w_log(W_LOG_FATAL, "pthread_create(reaper): %s\n",
strerror(errno));
return false;
}
if (!clients) {
clients = w_ht_new(2, &client_hash_funcs);
}
w_state_load();
#ifdef HAVE_LIBGIMLI_H
if (hb) {
gimli_heartbeat_set(hb, GIMLI_HB_RUNNING);
}
#endif
w_set_nonblock(listener_fd);
// Now run the dispatch
while (!stopping) {
int client_fd;
struct watchman_client *client;
struct pollfd pfd;
int bufsize;
#ifdef HAVE_LIBGIMLI_H
if (hb) {
gimli_heartbeat_set(hb, GIMLI_HB_RUNNING);
}
#endif
pfd.events = POLLIN;
pfd.fd = listener_fd;
if (poll(&pfd, 1, 10000) < 1 || (pfd.revents & POLLIN) == 0) {
continue;
}
#ifdef HAVE_ACCEPT4
client_fd = accept4(listener_fd, NULL, 0, SOCK_CLOEXEC);
#else
client_fd = accept(listener_fd, NULL, 0);
#endif
if (client_fd == -1) {
continue;
}
w_set_cloexec(client_fd);
bufsize = WATCHMAN_IO_BUF_SIZE;
setsockopt(client_fd, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
client = calloc(1, sizeof(*client));
client->fd = client_fd;
w_log(W_LOG_DBG, "accepted client %p fd=%d\n", client, client_fd);
if (!w_json_buffer_init(&client->reader)) {
// FIXME: error handling
}
if (!w_json_buffer_init(&client->writer)) {
// FIXME: error handling
}
if (pipe(client->ping)) {
// FIXME: error handling
}
client->subscriptions = w_ht_new(2, &subscription_hash_funcs);
w_set_cloexec(client->ping[0]);
w_set_nonblock(client->ping[0]);
w_set_cloexec(client->ping[1]);
w_set_nonblock(client->ping[1]);
pthread_mutex_lock(&w_client_lock);
w_ht_set(clients, client->fd, w_ht_ptr_val(client));
pthread_mutex_unlock(&w_client_lock);
// Start a thread for the client.
// We used to use libevent for this, but we have
// a low volume of concurrent clients and the json
// parse/encode APIs are not easily used in a non-blocking
// server architecture.
if (pthread_create(&thr, &attr, client_thread, client)) {
// It didn't work out, sorry!
pthread_mutex_lock(&w_client_lock);
w_ht_del(clients, client->fd);
pthread_mutex_unlock(&w_client_lock);
}
}
pthread_attr_destroy(&attr);
/* close out some resources to persuade valgrind to run clean */
close(listener_fd);
listener_fd = -1;
// Wait for clients, waking any sleeping clients up in the process
do {
w_ht_iter_t iter;
pthread_mutex_lock(&w_client_lock);
n_clients = w_ht_size(clients);
if (w_ht_first(clients, &iter)) do {
struct watchman_client *client = w_ht_val_ptr(iter.value);
ignore_result(write(client->ping[1], "a", 1));
} while (w_ht_next(clients, &iter));
pthread_mutex_unlock(&w_client_lock);
w_log(W_LOG_ERR, "waiting for %d clients to terminate\n", n_clients);
usleep(2000);
} while (n_clients > 0);
w_root_free_watched_roots();
pthread_join(reaper_thread, &ignored);
cfg_shutdown();
return true;
}
static int prepare_stdin(
struct watchman_trigger_command *cmd,
w_query_res *res)
{
uint32_t n_files;
char stdin_file_name[WATCHMAN_NAME_MAX];
int stdin_fd = -1;
if (cmd->stdin_style == input_dev_null) {
return open("/dev/null", O_RDONLY|O_CLOEXEC);
}
n_files = res->num_results;
if (cmd->max_files_stdin > 0) {
n_files = MIN(cmd->max_files_stdin, n_files);
}
/* prepare the input stream for the child process */
snprintf(stdin_file_name, sizeof(stdin_file_name), "%s/wmanXXXXXX",
watchman_tmp_dir);
stdin_fd = w_mkstemp(stdin_file_name);
if (stdin_fd == -1) {
w_log(W_LOG_ERR, "unable to create a temporary file: %s\n",
strerror(errno));
return -1;
}
/* unlink the file, we don't need it in the filesystem;
* we'll pass the fd on to the child as stdin */
unlink(stdin_file_name);
switch (cmd->stdin_style) {
case input_json:
{
w_jbuffer_t buffer;
json_t *file_list;
if (!w_json_buffer_init(&buffer)) {
w_log(W_LOG_ERR, "failed to init json buffer\n");
close(stdin_fd);
return -1;
}
file_list = w_query_results_to_json(&cmd->field_list,
n_files, res->results);
w_json_buffer_write(&buffer, stdin_fd, file_list, 0);
w_json_buffer_free(&buffer);
json_decref(file_list);
break;
}
case input_name_list:
{
struct iovec iov[2];
uint32_t i;
iov[1].iov_base = "\n";
iov[1].iov_len = 1;
for (i = 0; i < n_files; i++) {
iov[0].iov_base = (void*)res->results[i].relname->buf;
iov[0].iov_len = res->results[i].relname->len;
if (writev(stdin_fd, iov, 2) != (ssize_t)iov[0].iov_len + 1) {
w_log(W_LOG_ERR,
"write failure while producing trigger stdin: %s\n",
strerror(errno));
close(stdin_fd);
return -1;
}
}
break;
}
case input_dev_null:
// already handled above
break;
}
lseek(stdin_fd, 0, SEEK_SET);
return stdin_fd;
}
static bool try_command(json_t *cmd, int timeout)
{
int fd;
int res;
int tries;
int bufsize;
w_jbuffer_t buffer;
fd = socket(PF_LOCAL, SOCK_STREAM, 0);
if (fd == -1) {
perror("socket");
return false;
}
tries = 0;
do {
res = connect(fd, (struct sockaddr*)&un, sizeof(un));
if (res == 0) {
break;
}
if (timeout && tries < timeout && should_start(errno)) {
// Wait for socket to come up
sleep(1);
continue;
}
} while (++tries < timeout);
if (res) {
close(fd);
return false;
}
if (!cmd) {
close(fd);
return true;
}
bufsize = WATCHMAN_IO_BUF_SIZE;
setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));
w_json_buffer_init(&buffer);
// Send command
if (!w_ser_write_pdu(server_pdu, &buffer, fd, cmd)) {
w_log(W_LOG_ERR, "error sending PDU to server\n");
w_json_buffer_free(&buffer);
close(fd);
return false;
}
w_json_buffer_reset(&buffer);
do {
if (!w_json_buffer_passthru(&buffer, output_pdu, fd)) {
w_json_buffer_free(&buffer);
close(fd);
return false;
}
} while (persistent);
w_json_buffer_free(&buffer);
close(fd);
return true;
}
bool w_start_listener(const char *path)
{
struct sockaddr_un un;
pthread_t thr;
pthread_attr_t attr;
pthread_mutexattr_t mattr;
struct sigaction sa;
sigset_t sigset;
#ifdef HAVE_LIBGIMLI_H
volatile struct gimli_heartbeat *hb = NULL;
#endif
pthread_mutexattr_init(&mattr);
pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&w_client_lock, &mattr);
pthread_mutexattr_destroy(&mattr);
#ifdef HAVE_LIBGIMLI_H
hb = gimli_heartbeat_attach();
#endif
#ifdef HAVE_KQUEUE
{
struct rlimit limit;
int mib[2] = { CTL_KERN,
#ifdef KERN_MAXFILESPERPROC
KERN_MAXFILESPERPROC
#else
KERN_MAXFILES
#endif
};
int maxperproc;
size_t len;
len = sizeof(maxperproc);
sysctl(mib, 2, &maxperproc, &len, NULL, 0);
getrlimit(RLIMIT_NOFILE, &limit);
w_log(W_LOG_ERR, "file limit is %" PRIu64
" kern.maxfilesperproc=%i\n",
limit.rlim_cur, maxperproc);
if (limit.rlim_cur != RLIM_INFINITY &&
maxperproc > 0 &&
limit.rlim_cur < (rlim_t)maxperproc) {
limit.rlim_cur = maxperproc;
if (setrlimit(RLIMIT_NOFILE, &limit)) {
w_log(W_LOG_ERR,
"failed to raise limit to %" PRIu64 " (%s).\n",
limit.rlim_cur,
strerror(errno));
} else {
w_log(W_LOG_ERR,
"raised file limit to %" PRIu64 "\n",
limit.rlim_cur);
}
}
getrlimit(RLIMIT_NOFILE, &limit);
if (limit.rlim_cur < 10240) {
w_log(W_LOG_ERR,
"Your file descriptor limit is very low (%" PRIu64 "), "
"please consult the watchman docs on raising the limits\n",
limit.rlim_cur);
}
}
#endif
if (strlen(path) >= sizeof(un.sun_path) - 1) {
w_log(W_LOG_ERR, "%s: path is too long\n",
path);
return false;
}
signal(SIGPIPE, SIG_IGN);
/* allow SIGUSR1 and SIGCHLD to wake up a blocked thread, without restarting
* syscalls */
memset(&sa, 0, sizeof(sa));
sa.sa_handler = wakeme;
sa.sa_flags = 0;
sigaction(SIGUSR1, &sa, NULL);
sigaction(SIGCHLD, &sa, NULL);
// Block SIGCHLD everywhere
sigemptyset(&sigset);
sigaddset(&sigset, SIGCHLD);
sigprocmask(SIG_BLOCK, &sigset, NULL);
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
listener_fd = socket(PF_LOCAL, SOCK_STREAM, 0);
if (listener_fd == -1) {
w_log(W_LOG_ERR, "socket: %s\n",
strerror(errno));
return false;
}
un.sun_family = PF_LOCAL;
strcpy(un.sun_path, path);
if (bind(listener_fd, (struct sockaddr*)&un, sizeof(un)) != 0) {
w_log(W_LOG_ERR, "bind(%s): %s\n",
path, strerror(errno));
close(listener_fd);
return false;
}
if (listen(listener_fd, 200) != 0) {
w_log(W_LOG_ERR, "listen(%s): %s\n",
path, strerror(errno));
close(listener_fd);
return false;
}
w_set_cloexec(listener_fd);
if (pthread_create(&reaper_thread, NULL, child_reaper, NULL)) {
w_log(W_LOG_FATAL, "pthread_create(reaper): %s\n",
strerror(errno));
return false;
}
if (!clients) {
clients = w_ht_new(2, &client_hash_funcs);
}
// Wire up the command handlers
register_commands(commands);
w_state_load();
#ifdef HAVE_LIBGIMLI_H
if (hb) {
gimli_heartbeat_set(hb, GIMLI_HB_RUNNING);
}
w_set_nonblock(listener_fd);
#endif
// Now run the dispatch
while (true) {
int client_fd;
struct watchman_client *client;
struct pollfd pfd;
int bufsize;
#ifdef HAVE_LIBGIMLI_H
if (hb) {
gimli_heartbeat_set(hb, GIMLI_HB_RUNNING);
}
#endif
pfd.events = POLLIN;
pfd.fd = listener_fd;
poll(&pfd, 1, 10000);
client_fd = accept(listener_fd, NULL, 0);
if (client_fd == -1) {
continue;
}
w_set_cloexec(client_fd);
bufsize = WATCHMAN_IO_BUF_SIZE;
setsockopt(client_fd, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
client = calloc(1, sizeof(*client));
client->fd = client_fd;
if (!w_json_buffer_init(&client->reader)) {
// FIXME: error handling
}
if (!w_json_buffer_init(&client->writer)) {
// FIXME: error handling
}
if (pipe(client->ping)) {
// FIXME: error handling
}
client->subscriptions = w_ht_new(2, &subscription_hash_funcs);
w_set_cloexec(client->ping[0]);
w_set_nonblock(client->ping[0]);
w_set_cloexec(client->ping[1]);
w_set_nonblock(client->ping[1]);
pthread_mutex_lock(&w_client_lock);
w_ht_set(clients, client->fd, (w_ht_val_t)client);
pthread_mutex_unlock(&w_client_lock);
// Start a thread for the client.
// We used to use libevent for this, but we have
// a low volume of concurrent clients and the json
// parse/encode APIs are not easily used in a non-blocking
// server architecture.
if (pthread_create(&thr, &attr, client_thread, client)) {
// It didn't work out, sorry!
pthread_mutex_lock(&w_client_lock);
w_ht_del(clients, client->fd);
pthread_mutex_unlock(&w_client_lock);
}
}
pthread_attr_destroy(&attr);
return true;
}
static w_stm_t prepare_stdin(
struct watchman_trigger_command *cmd,
w_query_res *res)
{
uint32_t n_files;
char stdin_file_name[WATCHMAN_NAME_MAX];
w_stm_t stdin_file = NULL;
if (cmd->stdin_style == input_dev_null) {
return w_stm_open("/dev/null", O_RDONLY|O_CLOEXEC);
}
n_files = res->num_results;
if (cmd->max_files_stdin > 0) {
n_files = MIN(cmd->max_files_stdin, n_files);
}
/* prepare the input stream for the child process */
snprintf(stdin_file_name, sizeof(stdin_file_name), "%s%cwmanXXXXXX",
watchman_tmp_dir, WATCHMAN_DIR_SEP);
stdin_file = w_mkstemp(stdin_file_name);
if (!stdin_file) {
w_log(W_LOG_ERR, "unable to create a temporary file: %s %s\n",
stdin_file_name, strerror(errno));
return NULL;
}
/* unlink the file, we don't need it in the filesystem;
* we'll pass the fd on to the child as stdin */
unlink(stdin_file_name); // FIXME: windows path translation
switch (cmd->stdin_style) {
case input_json:
{
w_jbuffer_t buffer;
json_t *file_list;
if (!w_json_buffer_init(&buffer)) {
w_log(W_LOG_ERR, "failed to init json buffer\n");
w_stm_close(stdin_file);
return NULL;
}
file_list = w_query_results_to_json(&cmd->field_list,
n_files, res->results);
w_log(W_LOG_ERR, "input_json: sending json object to stm\n");
if (!w_json_buffer_write(&buffer, stdin_file, file_list, 0)) {
w_log(W_LOG_ERR,
"input_json: failed to write json data to stream: %s\n",
strerror(errno));
w_stm_close(stdin_file);
return NULL;
}
w_json_buffer_free(&buffer);
json_decref(file_list);
break;
}
case input_name_list:
{
uint32_t i;
for (i = 0; i < n_files; i++) {
if (w_stm_write(stdin_file, res->results[i].relname->buf,
res->results[i].relname->len) != (int)res->results[i].relname->len
|| w_stm_write(stdin_file, "\n", 1) != 1) {
w_log(W_LOG_ERR,
"write failure while producing trigger stdin: %s\n",
strerror(errno));
w_stm_close(stdin_file);
return NULL;
}
}
break;
}
case input_dev_null:
// already handled above
break;
}
w_stm_rewind(stdin_file);
return stdin_file;
}
