/*

 * misc.c - useful client functions

 *

 * This file is part of the SSH Library

 *

 * Copyright (c) 2003-2009 by Aris Adamantiadis

 * Copyright (c) 2008-2009 by Andreas Schneider <asn@cryptomilk.org>

 *

 * The SSH Library is free software; you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation; either version 2.1 of the License, or (at your

 * option) any later version.

 *

 * The SSH Library is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public

 * License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with the SSH Library; see the file COPYING.  If not, write to

 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,

 * MA 02111-1307, USA.

 */

#include "config.h"

#ifndef _WIN32

/* This is needed for a standard getpwuid_r on opensolaris */

#define _POSIX_PTHREAD_SEMANTICS

#include <pwd.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#endif /* _WIN32 */

#include <errno.h>

#include <limits.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <ctype.h>

#include <time.h>

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif /* HAVE_SYS_TIME_H */

#ifdef _WIN32

#ifndef _WIN32_IE

# define _WIN32_IE 0x0501 // SHGetSpecialFolderPath

#endif

#include <winsock2.h> // Must be the first to include

#include <ws2tcpip.h>

#include <shlobj.h>

#include <direct.h>

#ifdef HAVE_IO_H

#include <io.h>

#endif /* HAVE_IO_H */

#endif /* _WIN32 */

#include "libssh/priv.h"

#include "libssh/misc.h"

#include "libssh/session.h"

#ifdef HAVE_LIBGCRYPT

#define GCRYPT_STRING "/gnutls"

#else

#define GCRYPT_STRING ""

#endif

#ifdef HAVE_LIBCRYPTO

#define CRYPTO_STRING "/openssl"

#else

#define CRYPTO_STRING ""

#endif

#ifdef HAVE_LIBMBEDCRYPTO

#define MBED_STRING "/mbedtls"

#else

#define MBED_STRING ""

#endif

#ifdef WITH_ZLIB

#define ZLIB_STRING "/zlib"

#else

#define ZLIB_STRING ""

#endif

/**

 * @defgroup libssh_misc The SSH helper functions.

 * @ingroup libssh

 *

 * Different helper functions used in the SSH Library.

 *

 * @{

 */

#ifdef _WIN32

char *ssh_get_user_home_dir(void) {

  char tmp[MAX_PATH] = {0};

  char *szPath = NULL;

  if (SHGetSpecialFolderPathA(NULL, tmp, CSIDL_PROFILE, TRUE)) {

    szPath = malloc(strlen(tmp) + 1);

    if (szPath == NULL) {

      return NULL;

    }

    strcpy(szPath, tmp);

    return szPath;

  }

  return NULL;

}

/* we have read access on file */

int ssh_file_readaccess_ok(const char *file) {

  if (_access(file, 4) < 0) {

    return 0;

  }

  return 1;

}

/**

 * @brief Check if the given path is an existing directory and that is

 * accessible for writing.

 *

 * @param[in] path Path to the directory to be checked

 *

 * @return Return 1 if the directory exists and is accessible; 0 otherwise

 * */

int ssh_dir_writeable(const char *path)

{

    struct _stat buffer;

    int rc;

    rc = _stat(path, &buffer);

    if (rc < 0) {

        return 0;

    }

    if ((buffer.st_mode & _S_IFDIR) && (buffer.st_mode & _S_IWRITE)) {

        return 1;

    }

    return 0;

}

#define SSH_USEC_IN_SEC         1000000LL

#define SSH_SECONDS_SINCE_1601  11644473600LL

int gettimeofday(struct timeval *__p, void *__t) {

  union {

    unsigned long long ns100; /* time since 1 Jan 1601 in 100ns units */

    FILETIME ft;

  } now;

  GetSystemTimeAsFileTime (&now.ft);

  __p->tv_usec = (long) ((now.ns100 / 10LL) % SSH_USEC_IN_SEC);

  __p->tv_sec  = (long)(((now.ns100 / 10LL ) / SSH_USEC_IN_SEC) - SSH_SECONDS_SINCE_1601);

  return (0);

}

char *ssh_get_local_username(void) {

    DWORD size = 0;

    char *user;

    /* get the size */

    GetUserName(NULL, &size);

    user = (char *) malloc(size);

    if (user == NULL) {

        return NULL;

    }

    if (GetUserName(user, &size)) {

        return user;

    }

    return NULL;

}

int ssh_is_ipaddr_v4(const char *str) {

    struct sockaddr_storage ss;

    int sslen = sizeof(ss);

    int rc = SOCKET_ERROR;

    /* WSAStringToAddressA thinks that 0.0.0 is a valid IP */

    if (strlen(str) < 7) {

        return 0;

    }

    rc = WSAStringToAddressA((LPSTR) str,

                             AF_INET,

                             NULL,

                             (struct sockaddr*)&ss,

                             &sslen);

    if (rc == 0) {

        return 1;

    }

    return 0;

}

int ssh_is_ipaddr(const char *str) {

    int rc = SOCKET_ERROR;

    if (strchr(str, ':')) {

        struct sockaddr_storage ss;

        int sslen = sizeof(ss);

        /* TODO link-local (IP:v6:addr%ifname). */

        rc = WSAStringToAddressA((LPSTR) str,

                                 AF_INET6,

                                 NULL,

                                 (struct sockaddr*)&ss,

                                 &sslen);

        if (rc == 0) {

            return 1;

        }

    }

    return ssh_is_ipaddr_v4(str);

}

#else /* _WIN32 */

#ifndef NSS_BUFLEN_PASSWD

#define NSS_BUFLEN_PASSWD 4096

#endif /* NSS_BUFLEN_PASSWD */

char *ssh_get_user_home_dir(void)

{

    char *szPath = NULL;

    struct passwd pwd;

    struct passwd *pwdbuf = NULL;

    char buf[NSS_BUFLEN_PASSWD] = {0};

    int rc;

    rc = getpwuid_r(getuid(), &pwd, buf, NSS_BUFLEN_PASSWD, &pwdbuf);

    if (rc != 0 || pwdbuf == NULL ) {

        szPath = getenv("HOME");

        if (szPath == NULL) {

            return NULL;

        }

        snprintf(buf, sizeof(buf), "%s", szPath);

        return strdup(buf);

    }

    szPath = strdup(pwd.pw_dir);

    return szPath;

}

/* we have read access on file */

int ssh_file_readaccess_ok(const char *file)

{

    if (access(file, R_OK) < 0) {

        return 0;

    }

    return 1;

}

/**

 * @brief Check if the given path is an existing directory and that is

 * accessible for writing.

 *

 * @param[in] path Path to the directory to be checked

 *

 * @return Return 1 if the directory exists and is accessible; 0 otherwise

 * */

int ssh_dir_writeable(const char *path)

{

    struct stat buffer;

    int rc;

    rc = stat(path, &buffer);

    if (rc < 0) {

        return 0;

    }

    if (S_ISDIR(buffer.st_mode) && (buffer.st_mode & S_IWRITE)) {

        return 1;

    }

    return 0;

}

char *ssh_get_local_username(void)

{

    struct passwd pwd;

    struct passwd *pwdbuf = NULL;

    char buf[NSS_BUFLEN_PASSWD];

    char *name;

    int rc;

    rc = getpwuid_r(getuid(), &pwd, buf, NSS_BUFLEN_PASSWD, &pwdbuf);

    if (rc != 0 || pwdbuf == NULL) {

        return NULL;

    }

    name = strdup(pwd.pw_name);

    if (name == NULL) {

        return NULL;

    }

    return name;

}

int ssh_is_ipaddr_v4(const char *str) {

    int rc = -1;

    struct in_addr dest;

    rc = inet_pton(AF_INET, str, &dest);

    if (rc > 0) {

        return 1;

    }

    return 0;

}

int ssh_is_ipaddr(const char *str) {

    int rc = -1;

    if (strchr(str, ':')) {

        struct in6_addr dest6;

        /* TODO link-local (IP:v6:addr%ifname). */

        rc = inet_pton(AF_INET6, str, &dest6);

        if (rc > 0) {

            return 1;

        }

    }

    return ssh_is_ipaddr_v4(str);

}

#endif /* _WIN32 */

char *ssh_lowercase(const char* str) {

  char *new, *p;

  if (str == NULL) {

    return NULL;

  }

  new = strdup(str);

  if (new == NULL) {

    return NULL;

  }

  for (p = new; *p; p++) {

    *p = tolower(*p);

  }

  return new;

}

char *ssh_hostport(const char *host, int port)

{

    char *dest = NULL;

    size_t len;

    if (host == NULL) {

        return NULL;

    }

    /* 3 for []:, 5 for 65536 and 1 for nul */

    len = strlen(host) + 3 + 5 + 1;

    dest = malloc(len);

    if (dest == NULL) {

        return NULL;

    }

    snprintf(dest, len, "[%s]:%d", host, port);

    return dest;

}

/**

 * @brief Convert a buffer into a colon separated hex string.

 * The caller has to free the memory.

 *

 * @param  what         What should be converted to a hex string.

 *

 * @param  len          Length of the buffer to convert.

 *

 * @return              The hex string or NULL on error.

 *

 * @see ssh_string_free_char()

 */

char *ssh_get_hexa(const unsigned char *what, size_t len) {

    const char h[] = "0123456789abcdef";

    char *hexa;

    size_t i;

    size_t hlen = len * 3;

    if (len > (UINT_MAX - 1) / 3) {

        return NULL;

    }

    hexa = malloc(hlen + 1);

    if (hexa == NULL) {

        return NULL;

    }

    for (i = 0; i < len; i++) {

        hexa[i * 3] = h[(what[i] >> 4) & 0xF];

        hexa[i * 3 + 1] = h[what[i] & 0xF];

        hexa[i * 3 + 2] = ':';

    }

    hexa[hlen - 1] = '\0';

    return hexa;

}

/**

 * @deprecated          Please use ssh_print_hash() instead

 */

void ssh_print_hexa(const char *descr, const unsigned char *what, size_t len) {

    char *hexa = ssh_get_hexa(what, len);

    if (hexa == NULL) {

      return;

    }

    fprintf(stderr, "%s: %s\n", descr, hexa);

    free(hexa);

}

/**

 * @brief Log the content of a buffer in hexadecimal format, similar to the

 * output of 'hexdump -C' command.

 *

 * The first logged line is the given description followed by the length.

 * Then the content of the buffer is logged 16 bytes per line in the following

 * format:

 *

 * (offset) (first 8 bytes) (last 8 bytes) (the 16 bytes as ASCII char values)

 *

 * The output for a 16 bytes array containing values from 0x00 to 0x0f would be:

 *

 * "Example (16 bytes):"

 * "  00000000  00 01 02 03 04 05 06 07  08 09 0a 0b 0c 0d 0e 0f  ................"

 *

 * The value for each byte as corresponding ASCII character is printed at the

 * end if the value is printable. Otherwise it is replace with '.'.

 *

 * @param[in] descr A description for the content to be logged

 * @param[in] what  The buffer to be logged

 * @param[in] len   The length of the buffer given in what

 *

 * @note If a too long description is provided (which would result in a first

 * line longer than 80 bytes), the function will fail.

 */

void ssh_log_hexdump(const char *descr, const unsigned char *what, size_t len)

{

    size_t i;

    char ascii[17];

    const unsigned char *pc = NULL;

    size_t count = 0;

    ssize_t printed = 0;

    /* The required buffer size is calculated from:

     *

     *  2 bytes for spaces at the beginning

     *  8 bytes for the offset

     *  2 bytes for spaces

     * 24 bytes to print the first 8 bytes + spaces

     *  1 byte for an extra space

     * 24 bytes to print next 8 bytes + spaces

     *  2 bytes for extra spaces

     * 16 bytes for the content as ASCII characters at the end

     *  1 byte for the ending '\0'

     *

     * Resulting in 80 bytes.

     *

     * Except for the first line (description + size), all lines have fixed

     * length. If a too long description is used, the function will fail.

     * */

    char buffer[80];

    /* Print description */

    if (descr != NULL) {

        printed = snprintf(buffer, sizeof(buffer), "%s ", descr);

        if (printed < 0) {

            goto error;

        }

        count += printed;

    } else {

        printed = snprintf(buffer, sizeof(buffer), "(NULL description) ");

        if (printed < 0) {

            goto error;

        }

        count += printed;

    }

    if (len == 0) {

        printed = snprintf(buffer + count, sizeof(buffer) - count,

                           "(zero length):");

        if (printed < 0) {

            goto error;

        }

        SSH_LOG(SSH_LOG_DEBUG, "%s", buffer);

        return;

    } else {

        printed = snprintf(buffer + count, sizeof(buffer) - count,

                           "(%zu bytes):", len);

        if (printed < 0) {

            goto error;

        }

        count += printed;

    }

    if (what == NULL) {

        printed = snprintf(buffer + count, sizeof(buffer) - count,

                           "(NULL)");

        if (printed < 0) {

            goto error;

        }

        SSH_LOG(SSH_LOG_DEBUG, "%s", buffer);

        return;

    }

    SSH_LOG(SSH_LOG_DEBUG, "%s", buffer);

    /* Reset state */

    count = 0;

    pc = what;

    for (i = 0; i < len; i++) {

        /* Add one space after printing 8 bytes */

        if ((i % 8) == 0) {

            if (i != 0) {

                printed = snprintf(buffer + count, sizeof(buffer) - count, " ");

                if (printed < 0) {

                    goto error;

                }

                count += printed;

            }

        }

        /* Log previous line and reset state for new line */

        if ((i % 16) == 0) {

            if (i != 0) {

                printed = snprintf(buffer + count, sizeof(buffer) - count,

                                   "  %s", ascii);

                if (printed < 0) {

                    goto error;

                }

                SSH_LOG(SSH_LOG_DEBUG, "%s", buffer);

                count = 0;

            }

            /* Start a new line with the offset */

            printed = snprintf(buffer, sizeof(buffer),

                               "  %08zx ", i);

            if (printed < 0) {

                goto error;

            }

            count += printed;

        }

        /* Print the current byte hexadecimal representation */

        printed = snprintf(buffer + count, sizeof(buffer) - count,

                           " %02x", pc[i]);

        if (printed < 0) {

            goto error;

        }

        count += printed;

        /* If printable, store the ASCII character */

        if (isprint(pc[i])) {

            ascii[i % 16] = pc[i];

        } else {

            ascii[i % 16] = '.';

        }

        ascii[(i % 16) + 1] = '\0';

    }

    /* Add padding if not exactly 16 characters */

    while ((i % 16) != 0) {

        /* Add one space after printing 8 bytes */

        if ((i % 8) == 0) {

            if (i != 0) {

                printed = snprintf(buffer + count, sizeof(buffer) - count, " ");

                if (printed < 0) {

                    goto error;

                }

                count += printed;

            }

        }

        printed = snprintf(buffer + count, sizeof(buffer) - count, "   ");

        if (printed < 0) {

            goto error;

        }

        count += printed;

        i++;

    }

    /* Print the last printable part */

    printed = snprintf(buffer + count, sizeof(buffer) - count,

                       "   %s", ascii);

    if (printed < 0) {

        goto error;

    }

    SSH_LOG(SSH_LOG_DEBUG, "%s", buffer);

    return;

error:

    SSH_LOG(SSH_LOG_WARN, "Could not print to buffer");

    return;

}

/**

 * @brief Check if libssh is the required version or get the version

 * string.

 *

 * @param[in]  req_version The version required.

 *

 * @return              If the version of libssh is newer than the version

 *                      required it will return a version string.

 *                      NULL if the version is older.

 *

 * Example:

 *

 * @code

 *  if (ssh_version(SSH_VERSION_INT(0,2,1)) == NULL) {

 *    fprintf(stderr, "libssh version is too old!\n");

 *    exit(1);

 *  }

 *

 *  if (debug) {

 *    printf("libssh %s\n", ssh_version(0));

 *  }

 * @endcode

 */

const char *ssh_version(int req_version) {

  if (req_version <= LIBSSH_VERSION_INT) {

    return SSH_STRINGIFY(LIBSSH_VERSION) GCRYPT_STRING CRYPTO_STRING MBED_STRING

      ZLIB_STRING;

  }

  return NULL;

}

struct ssh_list *ssh_list_new(void) {

  struct ssh_list *ret=malloc(sizeof(struct ssh_list));

  if(!ret)

    return NULL;

  ret->root=ret->end=NULL;

  return ret;

}

void ssh_list_free(struct ssh_list *list){

  struct ssh_iterator *ptr,*next;

  if(!list)

    return;

  ptr=list->root;

  while(ptr){

    next=ptr->next;

    SAFE_FREE(ptr);

    ptr=next;

  }

  SAFE_FREE(list);

}

struct ssh_iterator *ssh_list_get_iterator(const struct ssh_list *list){

  if(!list)

    return NULL;

  return list->root;

}

struct ssh_iterator *ssh_list_find(const struct ssh_list *list, void *value){

  struct ssh_iterator *it;

  for(it = ssh_list_get_iterator(list); it != NULL ;it=it->next)

    if(it->data==value)

      return it;

  return NULL;

}

/**

 * @brief Get the number of elements in the list

 *

 * @param[in]  list     The list to count.

 *

 * @return The number of elements in the list.

 */

size_t ssh_list_count(const struct ssh_list *list)

{

  struct ssh_iterator *it = NULL;

  int count = 0;

  for (it = ssh_list_get_iterator(list); it != NULL ; it = it->next) {

      count++;

  }

  return count;

}

static struct ssh_iterator *ssh_iterator_new(const void *data){

  struct ssh_iterator *iterator=malloc(sizeof(struct ssh_iterator));

  if(!iterator)

    return NULL;

  iterator->next=NULL;

  iterator->data=data;

  return iterator;

}

int ssh_list_append(struct ssh_list *list,const void *data){

  struct ssh_iterator *iterator = NULL;

  if (list == NULL) {

      return SSH_ERROR;

  }

  iterator = ssh_iterator_new(data);

  if (iterator == NULL) {

      return SSH_ERROR;

  }

  if(!list->end){

    /* list is empty */

    list->root=list->end=iterator;

  } else {

    /* put it on end of list */

    list->end->next=iterator;

    list->end=iterator;

  }

  return SSH_OK;

}

int ssh_list_prepend(struct ssh_list *list, const void *data){

  struct ssh_iterator *it = NULL;

  if (list == NULL) {

      return SSH_ERROR;

  }

  it = ssh_iterator_new(data);

  if (it == NULL) {

    return SSH_ERROR;

  }

  if (list->end == NULL) {

    /* list is empty */

    list->root = list->end = it;

  } else {

    /* set as new root */

    it->next = list->root;

    list->root = it;

  }

  return SSH_OK;

}

void ssh_list_remove(struct ssh_list *list, struct ssh_iterator *iterator){

  struct ssh_iterator *ptr,*prev;

  if (list == NULL) {

      return;

  }

  prev=NULL;

  ptr=list->root;

  while(ptr && ptr != iterator){

    prev=ptr;

    ptr=ptr->next;

  }

  if(!ptr){

    /* we did not find the element */

    return;

  }

  /* unlink it */

  if(prev)

    prev->next=ptr->next;

  /* if iterator was the head */

  if(list->root == iterator)

    list->root=iterator->next;

  /* if iterator was the tail */

  if(list->end == iterator)

    list->end = prev;

  SAFE_FREE(iterator);

}

/**

 * @internal

 *

 * @brief Removes the top element of the list and returns the data value

 * attached to it.

 *

 * @param[in[  list     The ssh_list to remove the element.

 *

 * @returns             A pointer to the element being stored in head, or NULL

 *                      if the list is empty.

 */

const void *_ssh_list_pop_head(struct ssh_list *list){

  struct ssh_iterator *iterator = NULL;

  const void *data = NULL;

  if (list == NULL) {

      return NULL;

  }

  iterator = list->root;

  if (iterator == NULL) {

      return NULL;

  }

  data=iterator->data;

  list->root=iterator->next;

  if(list->end==iterator)

    list->end=NULL;

  SAFE_FREE(iterator);

  return data;

}

/**

 * @brief Parse directory component.

 *

 * dirname breaks a null-terminated pathname string into a directory component.

 * In the usual case, ssh_dirname() returns the string up to, but not including,

 * the final '/'. Trailing '/' characters are  not  counted as part of the

 * pathname. The caller must free the memory.

 *

 * @param[in]  path     The path to parse.

 *

 * @return              The dirname of path or NULL if we can't allocate memory.

 *                      If path does not contain a slash, c_dirname() returns

 *                      the string ".".  If path is the string "/", it returns

 *                      the string "/". If path is NULL or an empty string,

 *                      "." is returned.

 */

char *ssh_dirname (const char *path) {

  char *new = NULL;

  size_t len;

  if (path == NULL || *path == '\0') {

    return strdup(".");

  }

  len = strlen(path);

  /* Remove trailing slashes */

  while(len > 0 && path[len - 1] == '/') --len;

  /* We have only slashes */

  if (len == 0) {

    return strdup("/");

  }

  /* goto next slash */

  while(len > 0 && path[len - 1] != '/') --len;

  if (len == 0) {

    return strdup(".");

  } else if (len == 1) {

    return strdup("/");

  }

  /* Remove slashes again */

  while(len > 0 && path[len - 1] == '/') --len;

  new = malloc(len + 1);

  if (new == NULL) {

    return NULL;

  }