/* Tallocs *output off ctx; return false if command fails. */
bool run_command(const void *ctx, unsigned int *time_ms, char **output,
const char *fmt, ...)
{
va_list ap;
char *cmd;
bool ok;
unsigned int default_time = default_timeout_ms;
if (!time_ms)
time_ms = &default_time;
else if (*time_ms == 0) {
*output = talloc_strdup(ctx, "\n== TIMED OUT ==\n");
return false;
}
va_start(ap, fmt);
cmd = talloc_vasprintf(ctx, fmt, ap);
va_end(ap);
*output = run_with_timeout(ctx, cmd, &ok, time_ms);
if (ok)
return true;
if (!*output)
err(1, "Problem running child");
if (*time_ms == 0)
*output = talloc_asprintf_append(*output,
"\n== TIMED OUT ==\n");
return false;
}
char* read_body(int sock, char* buf, int bufsize)
{
struct recv_arg rvarg;
int sum_read;
int empty_buf_start;
int granularity;
granularity = 1024;
empty_buf_start = 0;
sum_read = 0;
if (buf)
{
buf = (char*)realloc(buf, granularity + bufsize);
sum_read = empty_buf_start = bufsize;
}
else
buf = (char*)malloc(granularity);
bufsize += granularity;
do
{
memset(&rvarg, 0, sizeof(struct recv_arg));
rvarg.s = sock;
rvarg.buf = buf + empty_buf_start;
rvarg.len = bufsize - sum_read;
rvarg.flags = 0;
/* First, peek at the available data. */
if (run_with_timeout(30, recv_with_timeout_callback, (void*)&rvarg))
{
free(buf);
return NULL;
}
if (rvarg.res > 0)
{
sum_read += rvarg.res;
empty_buf_start += rvarg.res;
}
if (sum_read >= bufsize)
{
buf = (char*)realloc (buf, bufsize + granularity);
bufsize += granularity;
}
}
while (rvarg.res > 0);
if (sum_read == bufsize)
buf = (char*)realloc (buf, bufsize + 1);
buf[sum_read]='\0';
if (rvarg.res == -1)
{
free(buf);
return NULL;
}
return buf;
}
bool
ssl_connect_wget (int fd, const char *hostname)
{
SSL *conn;
struct scwt_context scwt_ctx;
struct openssl_transport_context *ctx;
DEBUGP (("Initiating SSL handshake.\n"));
assert (ssl_ctx != NULL);
conn = SSL_new (ssl_ctx);
if (!conn)
goto error;
#if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
/* If the SSL library was build with support for ServerNameIndication
then use it whenever we have a hostname. If not, don't, ever. */
if (! is_valid_ip_address (hostname))
{
if (! SSL_set_tlsext_host_name (conn, hostname))
{
DEBUGP (("Failed to set TLS server-name indication."));
goto error;
}
}
#endif
#ifndef FD_TO_SOCKET
# define FD_TO_SOCKET(X) (X)
#endif
if (!SSL_set_fd (conn, FD_TO_SOCKET (fd)))
goto error;
SSL_set_connect_state (conn);
scwt_ctx.ssl = conn;
if (run_with_timeout(opt.read_timeout, ssl_connect_with_timeout_callback,
&scwt_ctx)) {
DEBUGP (("SSL handshake timed out.\n"));
goto timeout;
}
if (scwt_ctx.result <= 0 || conn->state != SSL_ST_OK)
goto error;
ctx = xnew0 (struct openssl_transport_context);
ctx->conn = conn;
/* Register FD with Wget's transport layer, i.e. arrange that our
functions are used for reading, writing, and polling. */
fd_register_transport (fd, &openssl_transport, ctx);
DEBUGP (("Handshake successful; connected socket %d to SSL handle 0x%0*lx\n",
fd, PTR_FORMAT (conn)));
return true;
error:
DEBUGP (("SSL handshake failed.\n"));
print_errors ();
timeout:
if (conn)
SSL_free (conn);
return false;
}
void main()
{
int ret = -1;
sleep_tm = 5;
ret = run_with_timeout(3, sleep_time, &sleep_tm);
printf("ret = %d \n", ret);
//schedule();
//printf("%lu \n", get_system_uptime(NULL));
}
static int
openssl_read (int fd, char *buf, int bufsize, void *arg)
{
struct openssl_read_args args;
args.fd = fd;
args.buf = buf;
args.bufsize = bufsize;
args.ctx = (struct openssl_transport_context*) arg;
if (run_with_timeout(opt.read_timeout, openssl_read_callback, &args)) {
return -1;
}
return args.retval;
}
static struct hostent *
gethostbyname_with_timeout (const char *host_name, double timeout)
{
struct ghbnwt_context ctx;
ctx.host_name = host_name;
if (run_with_timeout (timeout, gethostbyname_with_timeout_callback, &ctx))
{
SET_H_ERRNO (HOST_NOT_FOUND);
errno = ETIMEDOUT;
return NULL;
}
if (!ctx.hptr)
errno = 0;
return ctx.hptr;
}
static int
getaddrinfo_with_timeout (const char *node, const char *service,
const struct addrinfo *hints, struct addrinfo **res,
double timeout)
{
struct gaiwt_context ctx;
ctx.node = node;
ctx.service = service;
ctx.hints = hints;
ctx.res = res;
if (run_with_timeout (timeout, getaddrinfo_with_timeout_callback, &ctx))
{
errno = ETIMEDOUT;
return EAI_SYSTEM;
}
return ctx.exit_code;
}
static int
connect_with_timeout (int fd, const struct sockaddr *addr, socklen_t addrlen,
double timeout)
{
struct cwt_context ctx;
ctx.fd = fd;
ctx.addr = addr;
ctx.addrlen = addrlen;
if (run_with_timeout (timeout, connect_with_timeout_callback, &ctx))
{
errno = ETIMEDOUT;
return -1;
}
if (ctx.result == -1 && errno == EINTR)
errno = ETIMEDOUT;
return ctx.result;
}
char* receive_response(int sock, char** body, int* body_size)
{
long bufsize = 512;
char *buf = (char*)malloc (bufsize);
int tail = 0;
*body_size = 0;
while (1)
{
const char *end;
int remain;
struct recv_arg rvarg;
memset(&rvarg, 0, sizeof(struct recv_arg));
rvarg.s = sock;
rvarg.buf = buf + tail;
rvarg.len = bufsize - 1 - tail;
rvarg.flags = 0;
/* First, peek at the available data. */
if (run_with_timeout(30, recv_with_timeout_callback, (void*)&rvarg))
{
free (buf);
return NULL;
}
else if (rvarg.res < 0)
{
free (buf);
return NULL;
}
end = response_head_terminator(buf, buf + tail, rvarg.res);
if (end)
{
/* The data contains the terminator: we'll drain the data up
to the end of the terminator. */
remain = end - (buf + tail);
*body = (char*)malloc(rvarg.res - remain + 1);
memcpy(*body, end, rvarg.res - remain);
(*body)[rvarg.res - remain] = '\0';
*body_size = rvarg.res - remain;
if (remain == 0)
{
/* No more data needs to be read. */
buf[tail] = '\0';
return buf;
}
if (bufsize - 1 < tail + remain)
{
bufsize = tail + remain + 1;
buf = (char*)realloc(buf, bufsize);
buf[tail] = '\0';
return buf;
}
}
tail += rvarg.res;
buf[tail] = '\0';
if (rvarg.res == 0)
{
if (tail == 0)
{
/* EOF without anything having been read */
free (buf);
/*errno = 0;*/
return NULL;
}
else
/* EOF seen: return the data we've read. */
return buf;
}
/* Keep looping until all the data arrives. */
if (tail == bufsize - 1)
{
bufsize <<= 1;
buf = (char*)realloc (buf, bufsize);
}
}
}
