cf80f2f4b5
This introduces a test suite for libssh2. It runs OpenSSH in a Docker container because that works well on Windows (via docker-machine) as well as Linux. Presumably it works on Mac too with docker-machine, but I've not tested that. Because the test suite is docker-machine aware, you can also run it against a cloud provider, for more realistic network testing, by setting your cloud provider as your active docker machine. The Appveyor CI setup in this commit does that because Appveyor doesn't support docker locally.
316 строки
8.9 KiB
C
316 строки
8.9 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_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);
|
|
}
|