void
soup_message_io_client (SoupMessageQueueItem *item,
GIOStream *iostream,
GMainContext *async_context,
SoupMessageGetHeadersFn get_headers_cb,
SoupMessageParseHeadersFn parse_headers_cb,
gpointer header_data,
SoupMessageCompletionFn completion_cb,
gpointer completion_data)
{
SoupMessageIOData *io;
io = new_iostate (item->msg, iostream, async_context,
SOUP_MESSAGE_IO_CLIENT,
get_headers_cb, parse_headers_cb, header_data,
completion_cb, completion_data);
io->item = item;
soup_message_queue_item_ref (item);
io->cancellable = item->cancellable;
io->read_body = item->msg->response_body;
io->write_body = item->msg->request_body;
io->write_state = SOUP_MESSAGE_IO_STATE_HEADERS;
if (!item->new_api) {
gboolean blocking =
SOUP_IS_SESSION_SYNC (item->session) ||
(!SOUP_IS_SESSION_ASYNC (item->session) && !item->async);
io_run (item->msg, blocking);
}
}
bool
io_run_buf(const char **argv, char buf[], size_t bufsize)
{
struct io io;
return io_run(&io, IO_RD, NULL, NULL, argv) && io_read_buf(&io, buf, bufsize);
}
int
main(int argc, char *argv[])
{
struct sockaddr_un addr;
size_t addr_len;
int fd = socket(PF_UNIX, SOCK_STREAM, 0);
if (fd < 0) {
perror("socket");
exit(1);
}
addr.sun_family = AF_UNIX;
strcpy(addr.sun_path, "/tmp/nmd_ctrl");
addr_len = sizeof(addr);
if (connect(fd, (struct sockaddr *)&addr, addr_len) != 0) {
perror("connect");
exit(1);
}
conn = io_new_fd(fd);
struct io *io_in = io_new_fd(0);
io_watch(io_in, IO_IN, stdin_send, NULL);
io_run();
}
int
io_run_load(const char **argv, const char *separators,
io_read_fn read_property, void *data)
{
struct io io;
if (!io_run(&io, IO_RD, NULL, NULL, argv))
return ERR;
return io_load(&io, separators, read_property, data);
}
int
main(int argc, char *argv[])
{
signal(SIGINT, end);
http = roe_new("http", 9991);
roe_start(http, on_request);
io_run();
return 0;
}
int main(int argc, char *const argv[])
{
const char *prog = argv[0];
int c, i;
openlog("ohybridproxy", LOG_PERROR | LOG_PID, LOG_DAEMON);
uloop_init();
while ((c = getopt(argc, argv, "46a:p:h")) != -1) {
switch (c) {
case '4':
case '6':
/* Ignored for now */
break;
case 'a':
bindaddr = optarg;
break;
case 'p':
bindport = atoi(optarg);
break;
default:
goto help;
}
}
argc -= optind;
argv += optind;
if (argc == 0) {
help:
show_help(prog);
return 1;
}
for (i = 0 ; i < argc ; i++) {
char *ifname = argv[i];
char *domain = strchr(ifname, '=');
if (!domain) {
fprintf(stderr, "Invalid domain specification #%d (no =): %s",
i, ifname);
return 1;
}
*domain++ = 0;
/* Now we can do stuff with ifname+domain. */
if (!d2m_add_interface(ifname, domain)) {
L_ERR("Failed to add interface %s: %s", ifname, strerror(errno));
return 2;
}
}
return io_run(bindaddr, bindport, MAXIMUM_REQUEST_DURATION_IN_MS);
}
static gboolean
io_unpause_internal (gpointer msg)
{
SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
SoupMessageIOData *io = priv->io_data;
g_return_val_if_fail (io != NULL, FALSE);
g_clear_pointer (&io->unpause_source, g_source_unref);
io->paused = FALSE;
if (io->io_source)
return FALSE;
io_run (msg, FALSE);
return FALSE;
}
bool
index_diff(struct index_diff *diff, bool untracked, bool count_all)
{
const char *untracked_arg = !untracked ? "--untracked-files=no" :
count_all ? "--untracked-files=all" :
"--untracked-files=normal";
const char *status_argv[] = {
"git", "status", "--porcelain", "-z", untracked_arg, NULL
};
struct io io;
struct buffer buf;
bool ok = true;
memset(diff, 0, sizeof(*diff));
if (!io_run(&io, IO_RD, repo.cdup, NULL, status_argv))
return false;
while (io_get(&io, &buf, 0, true) && (ok = buf.size > 3)) {
if (buf.data[0] == '?')
diff->untracked++;
/* Ignore staged but unmerged entries. */
else if (buf.data[0] != ' ' && buf.data[0] != 'U')
diff->staged++;
if (buf.data[1] != ' ')
diff->unstaged++;
if (!count_all && diff->staged && diff->unstaged &&
(!untracked || diff->untracked))
break;
/* Skip source filename in rename */
if (buf.data[0] == 'R') {
io_get(&io, &buf, 0, true);
}
}
if (io_error(&io))
ok = false;
io_done(&io);
return ok;
}
void
soup_message_io_server (SoupMessage *msg,
GIOStream *iostream, GMainContext *async_context,
SoupMessageGetHeadersFn get_headers_cb,
SoupMessageParseHeadersFn parse_headers_cb,
gpointer header_data,
SoupMessageCompletionFn completion_cb,
gpointer completion_data)
{
SoupMessageIOData *io;
io = new_iostate (msg, iostream, async_context,
SOUP_MESSAGE_IO_SERVER,
get_headers_cb, parse_headers_cb, header_data,
completion_cb, completion_data);
io->read_body = msg->request_body;
io->write_body = msg->response_body;
io->read_state = SOUP_MESSAGE_IO_STATE_HEADERS;
io_run (msg, FALSE);
}
static void
setup_blame_parent_line(struct view *view, struct blame *blame)
{
char from[SIZEOF_REF + SIZEOF_STR];
char to[SIZEOF_REF + SIZEOF_STR];
const char *diff_tree_argv[] = {
"git", "diff", encoding_arg, "--no-textconv", "--no-extdiff",
"--no-color", "-U0", from, to, "--", NULL
};
struct io io;
int parent_lineno = -1;
int blamed_lineno = -1;
char *line;
if (!string_format(from, "%s:%s", view->env->ref, view->env->file) ||
!string_format(to, "%s:%s", blame->commit->id, blame->commit->filename) ||
!io_run(&io, IO_RD, NULL, opt_env, diff_tree_argv))
return;
while ((line = io_get(&io, '\n', TRUE))) {
if (*line == '@') {
char *pos = strchr(line, '+');
parent_lineno = atoi(line + 4);
if (pos)
blamed_lineno = atoi(pos + 1);
} else if (*line == '+' && parent_lineno != -1) {
if (blame->lineno == blamed_lineno - 1 &&
!strcmp(blame->text, line + 1)) {
view->pos.lineno = parent_lineno ? parent_lineno - 1 : 0;
break;
}
blamed_lineno++;
}
}
io_done(&io);
}
bool
index_diff(struct index_diff *diff, bool untracked, bool count_all)
{
const char *untracked_arg = !untracked ? "--untracked-files=no" :
count_all ? "--untracked-files=all" :
"--untracked-files=normal";
const char *status_argv[] = {
"git", "status", "--porcelain", "-z", untracked_arg, NULL
};
struct io io;
struct buffer buf;
bool ok = TRUE;
memset(diff, 0, sizeof(*diff));
if (!io_run(&io, IO_RD, repo.cdup, NULL, status_argv))
return FALSE;
while (io_get(&io, &buf, 0, TRUE) && (ok = buf.size > 3)) {
if (buf.data[0] == '?')
diff->untracked++;
else if (buf.data[0] != ' ')
diff->staged++;
if (buf.data[1] != ' ')
diff->unstaged++;
if (!count_all && diff->staged && diff->unstaged &&
(!untracked || diff->untracked))
break;
}
if (io_error(&io))
ok = FALSE;
io_done(&io);
return ok;
}
static gboolean
io_run_ready (SoupMessage *msg, gpointer user_data)
{
io_run (msg, FALSE);
return FALSE;
}
static void *aio_out_thread (void *param)
{
char *name = (char *) param;
int status;
io_context_t ctx = 0;
struct iocb *queue, *iocb;
unsigned i;
status = sink_open (name);
if (status < 0)
return 0;
sink_fd = status;
pthread_cleanup_push (close_fd, &sink_fd);
/* initialize i/o queue */
status = io_setup (aio_out, &ctx);
if (status < 0) {
perror ("aio_out_thread, io_setup");
return 0;
}
pthread_cleanup_push (queue_release, &ctx);
if (aio_out == 0)
aio_out = 1;
queue = alloca (aio_out * sizeof *iocb);
/* populate and (re)run the queue */
for (i = 0, iocb = queue; i < aio_out; i++, iocb++) {
char *buf = malloc (iosize);
if (!buf) {
fprintf(stderr, "%s can't get buffer[%d]\n",
__FUNCTION__, i);
return 0;
}
/* data can be processed in out_complete() */
io_prep_pread (iocb, sink_fd, buf, iosize, 0);
io_set_callback (iocb, out_complete);
iocb->key = USB_DIR_OUT;
status = io_submit (ctx, 1, &iocb);
if (status < 0) {
perror (__FUNCTION__);
break;
}
aio_out_pending++;
if (verbose > 2)
fprintf(stderr, "%s submit uiocb %p\n",
__FUNCTION__, iocb);
}
status = io_run (ctx, &aio_out_pending);
if (status < 0)
perror ("aio_out_thread, io_run");
/* clean up */
fflush (stderr);
pthread_cleanup_pop (1);
pthread_cleanup_pop (1);
return 0;
}
static void *aio_in_thread (void *param)
{
char *name = (char *) param;
int status;
io_context_t ctx = 0;
struct iocb *queue, *iocb;
unsigned i;
status = source_open (name);
if (status < 0)
return 0;
source_fd = status;
pthread_cleanup_push (close_fd, &source_fd);
/* initialize i/o queue */
status = io_setup (aio_in, &ctx);
if (status < 0) {
perror ("aio_in_thread, io_setup");
return 0;
}
pthread_cleanup_push (queue_release, &ctx);
if (aio_in == 0)
aio_in = 1;
queue = alloca (aio_in * sizeof *iocb);
/* populate and (re)run the queue */
for (i = 0, iocb = queue; i < aio_in; i++, iocb++) {
char *buf = malloc (iosize);
if (!buf) {
fprintf(stderr, "%s can't get buffer[%d]\n",
__FUNCTION__, i);
return 0;
}
/* host receives the data we're writing */
io_prep_pwrite (iocb, source_fd,
buf, fill_in_buf (buf, iosize),
0);
io_set_callback (iocb, in_complete);
iocb->key = USB_DIR_IN;
status = io_submit (ctx, 1, &iocb);
if (status < 0) {
perror (__FUNCTION__);
break;
}
aio_in_pending++;
if (verbose > 2)
fprintf(stderr, "%s submit uiocb %p\n",
__FUNCTION__, iocb);
}
status = io_run (ctx, &aio_in_pending);
if (status < 0)
perror ("aio_in_thread, io_run");
/* clean up */
fflush (stderr);
pthread_cleanup_pop (1);
pthread_cleanup_pop (1);
return 0;
}
