319 строки
9.0 KiB
C
319 строки
9.0 KiB
C
/* Copyright (C) 2016 Alexander Lamaison
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms,
|
|
* with or without modification, are permitted provided
|
|
* that the following conditions are met:
|
|
*
|
|
* Redistributions of source code must retain the above
|
|
* copyright notice, this list of conditions and the
|
|
* following disclaimer.
|
|
*
|
|
* Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials
|
|
* provided with the distribution.
|
|
*
|
|
* Neither the name of the copyright holder nor the names
|
|
* of any other contributors may be used to endorse or
|
|
* promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
|
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
|
|
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
|
|
* OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "openssh_fixture.h"
|
|
#include "libssh2_config.h"
|
|
|
|
#ifdef HAVE_WINSOCK2_H
|
|
#include <winsock2.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#ifdef HAVE_ARPA_INET_H
|
|
#include <arpa/inet.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#include <ctype.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
static int run_command(const char *command, char **output)
|
|
{
|
|
FILE *pipe;
|
|
char command_buf[BUFSIZ];
|
|
int ret;
|
|
if (output) {
|
|
*output = NULL;
|
|
}
|
|
|
|
/* Rewrite the command to redirect stderr to stdout to we can output it */
|
|
ret = snprintf(command_buf, sizeof(command_buf), "%s 2>&1", command);
|
|
if (ret < 0 || ret >= BUFSIZ) {
|
|
fprintf(stderr, "Unable to format command (%s)\n", command);
|
|
return -1;
|
|
}
|
|
|
|
fprintf(stdout, "Command: %s\n", command);
|
|
#ifdef WIN32
|
|
pipe = _popen(command_buf, "r");
|
|
#else
|
|
pipe = popen(command_buf, "r");
|
|
#endif
|
|
if (pipe) {
|
|
char buf[BUFSIZ];
|
|
char *p = buf;
|
|
while (fgets(p, sizeof(buf) - (p - buf), pipe) != NULL)
|
|
;
|
|
|
|
#ifdef WIN32
|
|
ret = _pclose(pipe);
|
|
#else
|
|
ret = pclose(pipe);
|
|
#endif
|
|
if (ret == 0) {
|
|
if (output) {
|
|
/* command output may contain a trailing newline, so we trim
|
|
* whitespace here */
|
|
size_t end = strlen(buf) - 1;
|
|
while (end > 0 && isspace(buf[end])) {
|
|
buf[end] = '\0';
|
|
}
|
|
|
|
*output = strdup(buf);
|
|
}
|
|
}
|
|
else {
|
|
fprintf(stderr, "Error running command '%s' (exit %d): %s\n",
|
|
command, ret, buf);
|
|
}
|
|
return ret;
|
|
}
|
|
else {
|
|
fprintf(stderr, "Unable to execute command '%s'\n", command);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
static int build_openssh_server_docker_image()
|
|
{
|
|
return run_command("docker build -t libssh2/openssh_server openssh_server",
|
|
NULL);
|
|
}
|
|
|
|
static int start_openssh_server(char **container_id_out)
|
|
{
|
|
return run_command("docker run --detach -P libssh2/openssh_server",
|
|
container_id_out);
|
|
}
|
|
|
|
static int stop_openssh_server(char *container_id)
|
|
{
|
|
char command_buf[BUFSIZ];
|
|
int rc = snprintf(command_buf, sizeof(command_buf), "docker stop %s",
|
|
container_id);
|
|
if (rc > -1 && rc < BUFSIZ) {
|
|
return run_command(command_buf, NULL);
|
|
}
|
|
else {
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
static const char *docker_machine_name()
|
|
{
|
|
return getenv("DOCKER_MACHINE_NAME");
|
|
}
|
|
|
|
static int ip_address_from_container(char *container_id, char **ip_address_out)
|
|
{
|
|
const char *active_docker_machine = docker_machine_name();
|
|
if (active_docker_machine != NULL) {
|
|
|
|
// This can be flaky when tests run in parallel (see
|
|
// https://github.com/docker/machine/issues/2612), so we retry a few
|
|
// times with exponential backoff if it fails
|
|
int attempt_no = 0;
|
|
int wait_time = 500;
|
|
for (;;) {
|
|
char command_buf[BUFSIZ];
|
|
int rc = snprintf(command_buf, sizeof(command_buf),
|
|
"docker-machine ip %s", active_docker_machine);
|
|
if (rc > -1 && rc < BUFSIZ) {
|
|
return run_command(command_buf, ip_address_out);
|
|
}
|
|
|
|
if (attempt_no > 5) {
|
|
fprintf(
|
|
stderr,
|
|
"Unable to get IP from docker-machine after %d attempts\n",
|
|
attempt_no);
|
|
return -1;
|
|
}
|
|
else {
|
|
#ifdef WIN32
|
|
#pragma warning(push)
|
|
#pragma warning(disable : 4996)
|
|
_sleep(wait_time);
|
|
#pragma warning(pop)
|
|
#else
|
|
sleep(wait_time);
|
|
#endif
|
|
++attempt_no;
|
|
wait_time *= 2;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
char command_buf[BUFSIZ];
|
|
int rc = snprintf(
|
|
command_buf, sizeof(command_buf),
|
|
"docker inspect --format \"{{ index (index (index "
|
|
".NetworkSettings.Ports \\\"22/tcp\\\") 0) \\\"HostIp\\\" }}\" %s",
|
|
container_id);
|
|
if (rc > -1 && rc < BUFSIZ) {
|
|
return run_command(command_buf, ip_address_out);
|
|
}
|
|
else {
|
|
return rc;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int port_from_container(char *container_id, char **port_out)
|
|
{
|
|
char command_buf[BUFSIZ];
|
|
int rc = snprintf(
|
|
command_buf, sizeof(command_buf),
|
|
"docker inspect --format \"{{ index (index (index "
|
|
".NetworkSettings.Ports \\\"22/tcp\\\") 0) \\\"HostPort\\\" }}\" %s",
|
|
container_id);
|
|
if (rc > -1 && rc < BUFSIZ) {
|
|
return run_command(command_buf, port_out);
|
|
}
|
|
else {
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
static int open_socket_to_container(char *container_id)
|
|
{
|
|
char *ip_address = NULL;
|
|
|
|
int ret = ip_address_from_container(container_id, &ip_address);
|
|
if (ret == 0) {
|
|
char *port_string = NULL;
|
|
ret = port_from_container(container_id, &port_string);
|
|
if (ret == 0) {
|
|
unsigned long hostaddr = inet_addr(ip_address);
|
|
if (hostaddr != (unsigned long)(-1)) {
|
|
int sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
if (sock > -1) {
|
|
struct sockaddr_in sin;
|
|
|
|
sin.sin_family = AF_INET;
|
|
sin.sin_port = htons((short)strtol(port_string, NULL, 0));
|
|
sin.sin_addr.s_addr = hostaddr;
|
|
|
|
if (connect(sock, (struct sockaddr *)(&sin),
|
|
sizeof(struct sockaddr_in)) == 0) {
|
|
ret = sock;
|
|
}
|
|
else {
|
|
fprintf(stderr, "Failed to connect to %s:%s\n",
|
|
ip_address, port_string);
|
|
ret = -1;
|
|
}
|
|
}
|
|
else {
|
|
fprintf(stderr, "Failed to open socket (%d)\n", sock);
|
|
ret = -1;
|
|
}
|
|
}
|
|
else {
|
|
fprintf(stderr, "Failed to convert %s host address\n",
|
|
ip_address);
|
|
ret = -1;
|
|
}
|
|
|
|
free(port_string);
|
|
}
|
|
else {
|
|
fprintf(stderr, "Failed to get port for container %s\n",
|
|
container_id);
|
|
ret = -1;
|
|
}
|
|
|
|
free(ip_address);
|
|
}
|
|
else {
|
|
fprintf(stderr, "Failed to get IP address for container %s\n",
|
|
container_id);
|
|
ret = -1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static char *running_container_id = NULL;
|
|
|
|
int start_openssh_fixture()
|
|
{
|
|
int ret;
|
|
#ifdef HAVE_WINSOCK2_H
|
|
WSADATA wsadata;
|
|
|
|
ret = WSAStartup(MAKEWORD(2, 0), &wsadata);
|
|
if (ret != 0) {
|
|
fprintf(stderr, "WSAStartup failed with error: %d\n", ret);
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
ret = build_openssh_server_docker_image();
|
|
if (ret == 0) {
|
|
return start_openssh_server(&running_container_id);
|
|
}
|
|
else {
|
|
fprintf(stderr, "Failed to build docker image\n");
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
void stop_openssh_fixture()
|
|
{
|
|
if (running_container_id) {
|
|
stop_openssh_server(running_container_id);
|
|
free(running_container_id);
|
|
running_container_id = NULL;
|
|
}
|
|
else {
|
|
fprintf(stderr, "Cannot stop container - none started");
|
|
}
|
|
}
|
|
|
|
int open_socket_to_openssh_server()
|
|
{
|
|
return open_socket_to_container(running_container_id);
|
|
}
|