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 read_response(w_jbuffer_t *reader, int fd)
{
json_t *j;
json_error_t jerr;
if (no_pretty) {
// Just pass through what we get from the server.
// We use the buffer space from reader.
int x;
size_t res;
char *buf;
bool is_done = false;
while (!is_done) {
x = read(fd, reader->buf, reader->allocd);
if (x <= 0) {
return true;
}
if (memchr(reader->buf, '\n', x)) {
is_done = true;
}
buf = reader->buf;
while (x > 0) {
res = fwrite(buf, 1, x, stdout);
if (res == 0) {
break;
}
buf += res;
x -= res;
}
}
return true;
}
j = w_json_buffer_next(reader, fd, &jerr);
if (!j) {
w_log(W_LOG_ERR, "failed to parse response: %s\n",
jerr.text);
return false;
}
// Let's just pretty print the JSON response
json_dumpf(j, stdout, JSON_INDENT(4));
printf("\n");
json_decref(j);
return true;
}
// The client thread reads and decodes json packets,
// then dispatches the commands that it finds
static void *client_thread(void *ptr)
{
struct watchman_client *client = ptr;
struct pollfd pfd[2];
json_t *request;
json_error_t jerr;
char buf[16];
w_set_nonblock(client->fd);
while (!stopping) {
// Wait for input from either the client socket or
// via the ping pipe, which signals that some other
// thread wants to unilaterally send data to the client
pfd[0].fd = client->fd;
pfd[0].events = POLLIN|POLLHUP|POLLERR;
pfd[0].revents = 0;
pfd[1].fd = client->ping[0];
pfd[1].events = POLLIN|POLLHUP|POLLERR;
pfd[1].revents = 0;
ignore_result(poll(pfd, 2, 200));
if (stopping) {
break;
}
if (pfd[0].revents & (POLLHUP|POLLERR)) {
w_log(W_LOG_DBG, "got HUP|ERR on client %p fd=%d, disconnecting\n",
client, client->fd);
break;
}
if (pfd[0].revents) {
// Solaris: we may not detect POLLHUP until we try to read, so
// let's peek ahead and characterize it correctly. This is only
// needed if we have no data buffered
if (client->reader.wpos == client->reader.rpos) {
char peek;
if (recv(client->fd, &peek, sizeof(peek), MSG_PEEK) == 0) {
w_log(W_LOG_DBG, "got HUP|ERR on client fd=%d, disconnecting\n",
client->fd);
goto disconected;
}
}
request = w_json_buffer_next(&client->reader, client->fd, &jerr);
if (!request && errno == EAGAIN) {
// That's fine
} else if (!request) {
// Not so cool
send_error_response(client, "invalid json at position %d: %s",
jerr.position, jerr.text);
w_log(W_LOG_ERR, "invalid data from client: %s\n", jerr.text);
goto disconected;
} else if (request) {
client->pdu_type = client->reader.pdu_type;
dispatch_command(client, request, CMD_DAEMON);
json_decref(request);
}
}
if (pfd[1].revents) {
ignore_result(read(client->ping[0], buf, sizeof(buf)));
}
/* now send our response(s) */
while (client->head) {
struct watchman_client_response *resp;
/* de-queue the first response */
pthread_mutex_lock(&w_client_lock);
resp = client->head;
if (resp) {
client->head = resp->next;
if (client->tail == resp) {
client->tail = NULL;
}
}
pthread_mutex_unlock(&w_client_lock);
if (resp) {
w_clear_nonblock(client->fd);
/* Return the data in the same format that was used to ask for it */
w_ser_write_pdu(client->pdu_type, &client->writer,
client->fd, resp->json);
json_decref(resp->json);
free(resp);
w_set_nonblock(client->fd);
}
}
}
disconected:
pthread_mutex_lock(&w_client_lock);
w_ht_del(clients, client->fd);
pthread_mutex_unlock(&w_client_lock);
return NULL;
}
// The client thread reads and decodes json packets,
// then dispatches the commands that it finds
static void *client_thread(void *ptr)
{
struct watchman_client *client = ptr;
struct pollfd pfd[2];
json_t *request;
json_error_t jerr;
char buf[16];
w_set_nonblock(client->fd);
while (true) {
// Wait for input from either the client socket or
// via the ping pipe, which signals that some other
// thread wants to unilaterally send data to the client
pfd[0].fd = client->fd;
pfd[0].events = POLLIN|POLLHUP|POLLERR;
pfd[0].revents = 0;
pfd[1].fd = client->ping[0];
pfd[1].events = POLLIN|POLLHUP|POLLERR;
pfd[1].revents = 0;
ignore_result(poll(pfd, 2, 200));
if (pfd[0].revents & (POLLHUP|POLLERR)) {
disconected:
pthread_mutex_lock(&w_client_lock);
w_ht_del(clients, client->fd);
pthread_mutex_unlock(&w_client_lock);
break;
}
if (pfd[0].revents) {
request = w_json_buffer_next(&client->reader, client->fd, &jerr);
if (!request && errno == EAGAIN) {
// That's fine
} else if (!request) {
// Not so cool
send_error_response(client, "invalid json at position %d: %s",
jerr.position, jerr.text);
w_log(W_LOG_ERR, "invalid data from client: %s\n", jerr.text);
goto disconected;
} else if (request) {
client->pdu_type = client->reader.pdu_type;
dispatch_command(client, request);
json_decref(request);
}
}
if (pfd[1].revents) {
ignore_result(read(client->ping[0], buf, sizeof(buf)));
}
/* now send our response(s) */
while (client->head) {
struct watchman_client_response *resp;
/* de-queue the first response */
pthread_mutex_lock(&w_client_lock);
resp = client->head;
if (resp) {
client->head = resp->next;
if (client->tail == resp) {
client->tail = NULL;
}
}
pthread_mutex_unlock(&w_client_lock);
if (resp) {
w_clear_nonblock(client->fd);
/* Return the data in the same format that was used to ask for it */
w_ser_write_pdu(client->pdu_type, &client->writer,
client->fd, resp->json);
json_decref(resp->json);
free(resp);
w_set_nonblock(client->fd);
}
}
}
return NULL;
}
// The client thread reads and decodes json packets,
// then dispatches the commands that it finds
static void *client_thread(void *ptr)
{
struct watchman_client *client = ptr;
struct watchman_event_poll pfd[2];
json_t *request;
json_error_t jerr;
w_stm_set_nonblock(client->stm, true);
w_set_thread_name("client:stm=%p", client->stm);
w_stm_get_events(client->stm, &pfd[0].evt);
pfd[1].evt = client->ping;
while (!stopping) {
// Wait for input from either the client socket or
// via the ping pipe, which signals that some other
// thread wants to unilaterally send data to the client
ignore_result(w_poll_events(pfd, 2, 2000));
if (stopping) {
break;
}
if (pfd[0].ready) {
request = w_json_buffer_next(&client->reader, client->stm, &jerr);
if (!request && errno == EAGAIN) {
// That's fine
} else if (!request) {
// Not so cool
if (client->reader.wpos == client->reader.rpos) {
// If they disconnected in between PDUs, no need to log
// any error
goto disconected;
}
send_error_response(client, "invalid json at position %d: %s",
jerr.position, jerr.text);
w_log(W_LOG_ERR, "invalid data from client: %s\n", jerr.text);
goto disconected;
} else if (request) {
client->pdu_type = client->reader.pdu_type;
dispatch_command(client, request, CMD_DAEMON);
json_decref(request);
}
}
if (pfd[1].ready) {
w_event_test_and_clear(client->ping);
}
/* now send our response(s) */
while (client->head) {
struct watchman_client_response *resp;
/* de-queue the first response */
pthread_mutex_lock(&w_client_lock);
resp = client->head;
if (resp) {
client->head = resp->next;
if (client->tail == resp) {
client->tail = NULL;
}
}
pthread_mutex_unlock(&w_client_lock);
if (resp) {
bool ok;
w_stm_set_nonblock(client->stm, false);
/* Return the data in the same format that was used to ask for it */
ok = w_ser_write_pdu(client->pdu_type, &client->writer,
client->stm, resp->json);
json_decref(resp->json);
free(resp);
w_stm_set_nonblock(client->stm, true);
if (!ok) {
break;
}
}
}
}
disconected:
pthread_mutex_lock(&w_client_lock);
w_ht_del(clients, w_ht_ptr_val(client));
pthread_mutex_unlock(&w_client_lock);
return NULL;
}
// The client thread reads and decodes json packets,
// then dispatches the commands that it finds
static void *client_thread(void *ptr)
{
struct watchman_client *client = ptr;
struct watchman_event_poll pfd[2];
struct watchman_client_response *queued_responses_to_send;
json_t *request;
json_error_t jerr;
bool send_ok = true;
w_stm_set_nonblock(client->stm, true);
w_set_thread_name("client=%p:stm=%p", client, client->stm);
client->client_is_owner = w_stm_peer_is_owner(client->stm);
w_stm_get_events(client->stm, &pfd[0].evt);
pfd[1].evt = client->ping;
while (!stopping) {
// Wait for input from either the client socket or
// via the ping pipe, which signals that some other
// thread wants to unilaterally send data to the client
ignore_result(w_poll_events(pfd, 2, 2000));
if (stopping) {
break;
}
if (pfd[0].ready) {
request = w_json_buffer_next(&client->reader, client->stm, &jerr);
if (!request && errno == EAGAIN) {
// That's fine
} else if (!request) {
// Not so cool
if (client->reader.wpos == client->reader.rpos) {
// If they disconnected in between PDUs, no need to log
// any error
goto disconected;
}
send_error_response(client, "invalid json at position %d: %s",
jerr.position, jerr.text);
w_log(W_LOG_ERR, "invalid data from client: %s\n", jerr.text);
goto disconected;
} else if (request) {
client->pdu_type = client->reader.pdu_type;
dispatch_command(client, request, CMD_DAEMON);
json_decref(request);
}
}
if (pfd[1].ready) {
w_event_test_and_clear(client->ping);
}
/* de-queue the pending responses under the lock */
pthread_mutex_lock(&w_client_lock);
queued_responses_to_send = client->head;
client->head = NULL;
client->tail = NULL;
pthread_mutex_unlock(&w_client_lock);
/* now send our response(s) */
while (queued_responses_to_send) {
struct watchman_client_response *response_to_send =
queued_responses_to_send;
if (send_ok) {
w_stm_set_nonblock(client->stm, false);
/* Return the data in the same format that was used to ask for it.
* Don't bother sending any more messages if the client disconnects,
* but still free their memory.
*/
send_ok = w_ser_write_pdu(client->pdu_type, &client->writer,
client->stm, response_to_send->json);
w_stm_set_nonblock(client->stm, true);
}
queued_responses_to_send = response_to_send->next;
json_decref(response_to_send->json);
free(response_to_send);
}
}
disconected:
w_set_thread_name("NOT_CONN:client=%p:stm=%p", client, client->stm);
// Remove the client from the map before we tear it down, as this makes
// it easier to flush out pending writes on windows without worrying
// about w_log_to_clients contending for the write buffers
pthread_mutex_lock(&w_client_lock);
w_ht_del(clients, w_ht_ptr_val(client));
pthread_mutex_unlock(&w_client_lock);
client_delete(client);
return NULL;
}
