원격 접속 자동화 (3) 추가: libssh2 활용 코드

몇가지 예제를 남겨두고자 한다.

아래는 예제에서 사용되는 구조체이다.

struct ssh2_manager
{
    char *cmd;
    unsigned long addr;
    int sock;
    LIBSSH2_SESSION *session;
    LIBSSH2_CHANNEL *channel;
    time_t when;

    void *linkage;

    struct ssh2_manager *next;
}; // ssh를 통해 내리는 커맨드 하나를 저장하는 단위 구조체.

struct ssh2_poller
{
    LIBSSH2_POLLFD *pollfds;
    struct ssh2_manager *stms;

    int nfds;
    int max_nfds;
}; // 실행된 커맨드들의 응답 대기를 위한 pool 구조체

ssh2_manager 구조체는 아래와 같이 초기화된다.

// addr : 원격 Server의 주소.
// cmd : 원격 Server에서 실행할 명령
// linkage : 별도의 데이터 저장이 필요한 경우 사용
struct ssh2_manager *ssh2_new_manager(unsigned long addr, char *cmd, void *linkage)
{
    struct ssh2_manager *stm;

    stm = (struct ssh2_manager *)malloc(sizeof(struct ssh2_manager));

    if (stm) {
        memset((char *)stm, 0, sizeof(struct ssh2_manager));

        stm->cmd = cmd;
        stm->addr = addr;
        stm->when = time(0);
        stm->linkage = linkage;
    }

    return stm;
}

ssh2_manager 구조체를 초기화 한 후에, cmd로 입력된 명령을 원격 Server에서 실행하게 하는 명령이다.

int ssh2_execute(struct ssh2_manager *stm)
{
    struct sockaddr_in sin;
    int retval = 0;

    stm->sock = socket(AF_INET, SOCK_STREAM, 0);
    sin.sin_family = AF_INET;
    sin.sin_port = htons(22); // 원격 port는 항상 22를 가정했다.
    sin.sin_addr.s_addr = stm->addr;

    if (connect(stm->sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in)) != 0) { // 원격 Server로 기본 socket을 연결한다.
        return -1;
    }

    // libssh2의 초기화 과정에는 libssh와는 다르게, 이와 같이 별도로 Socket을 생성하여 원격 Server에 연결한 이후 해당 Socket을 입력받아 초기화를 수행한다.
    stm->session = libssh2_session_init();
    if (libssh2_session_startup(stm->session, stm->sock)) {
        return -2;
    }

    // 별도로 제작한 인증 관련 함수이다. 각종 key와 관련된 사항들이 문자열로 입력된다.
    if (libssh2_userauth_publickey_fromstring(stm->session, "root", PUBLIC_KEY_STRING, PUBLIC_KEY_STRING_LEN, PRIVATE_KEY_STRING, KEY_PASSWORD)) {
        retval = -3;
        goto shutdown;
    }

    // session에서 channel을 할당 받는다. 이 channel을 통하여 커맨드를 주고 받는다.
    if (!(stm->channel = libssh2_channel_open_session(stm->session))) {
        retval = -4;
        goto shutdown;
    }

    // channel을 규정한다. vanilla는 terminal의 일종인듯 하다. (예제에서 그대로 복사한 것이다!)
    if (libssh2_channel_request_pty(stm->channel, "vanilla")) {
        retval = -5;
        goto shutdown;
    }

    // channel을 nonblock 모드로 설정한다. (라고 알고 있다.)
    libssh2_channel_set_blocking(stm->channel, 0);
    // channel을 통해서 명령을 내린다.
    if (libssh2_channel_exec(stm->channel, stm->cmd)) {
        retval = -6;
        goto shutdown;
    }

    return retval;

shutdown:
    ssh2_shutdown(stm);

    return retval;
}

여기까지 명령을 내린 과정 되겠다. 이렇게 명령을 내린 이후에는 Interactive한 처리를 위해 결과가 필요하다. libssh2는 이를 위해 libssh2_poll이라는 함수를 제공한다.
명령을 내리고 응답을 기다리는 ssh2_manager 구조체들을 관리하고 응답이 왔는지 확인시켜주는 용도로 ssh2_poller라는 구조체를 초기화한다.

#define POLLER_NUMBER_GUIDE     10

struct ssh2_poller *ssh2_new_poller(struct ssh2_poller *stp, struct ssh2_manager *stm)
{
    if (stp == NULL) { // 최초 stp가 NULL일 경우 초기화한다.
        stp = (struct ssh2_poller *)malloc(sizeof(struct ssh2_poller));
        stp->pollfds = (LIBSSH2_POLLFD *)malloc(sizeof(LIBSSH2_POLLFD) * POLLER_NUMBER_GUIDE);
        memset((char *)stp->pollfds, 0, sizeof(LIBSSH2_POLLFD) * POLLER_NUMBER_GUIDE);
        stp->nfds = 0;
        stp->max_nfds = POLLER_NUMBER_GUIDE;
    }
    if ((stp->nfds + 1) >= stp->max_nfds) { // stp가 존재하고, 그 Capacity가 넘어갔을 경우, Capacity를 POLLER_NUMBER_GUIDE 만큼 증가시킨다.
        LIBSSH2_POLLFD *newpollfds;

        stp->max_nfds += POLLER_NUMBER_GUIDE;
        newpollfds = (LIBSSH2_POLLFD *)malloc(sizeof(LIBSSH2_POLLFD) * stp->max_nfds);
        memset((char *)newpollfds, 0, sizeof(LIBSSH2_POLLFD) * stp->max_nfds);
        memcpy((char *)newpollfds, (char *)stp->pollfds, sizeof(LIBSSH2_POLLFD) * stp->nfds);

        free(stp->pollfds);
        stp->pollfds = newpollfds;
    }

    // 실제 ssh2_manager 구조체가 ssh2_poller 구조체에 입력되는 과정이다.
    (stp->pollfds + stp->nfds)->type = LIBSSH2_POLLFD_CHANNEL;
    (stp->pollfds + stp->nfds)->fd.channel = stm->channel;
    (stp->pollfds + stp->nfds)->events = POLLRDNORM | POLLRDBAND | POLLHUP | POLLERR;
    (stp->pollfds + stp->nfds)->revents = 0;

    stm->next = stp->stms;
    stp->stms = stm;

    stp->nfds++;

    return stp;
}

그리고, polling을 수행한다.

int ssh2_polling(struct ssh2_poller *stp)
{
    return libssh2_poll(stp->pollfds, stp->nfds, 1);
}

그런 후에 ssh2_poller에 등록된 ssh2_manager중에 원격 Server로 부터의 응답을 가지고 있는 서버를 알아낸다.

// 별로 코멘트가 필요하지 않다;
struct ssh2_manager *ssh2_poller_readable(struct ssh2_poller *stp)
{
    int i;
    struct ssh2_manager *stm;

    for (i = 0; i < stp->nfds; i++) {
        if ((stp->pollfds + i)->revents & POLLRDNORM ||
            (stp->pollfds + i)->revents & POLLRDBAND) {

            (stp->pollfds + i)->revents = 0;
            for (stm = stp->stms; stm; stm = stm->next) {
                if (stm->channel == (stp->pollfds + i)->fd.channel) {
                    return stm;
                }
            }
            return NULL;
        }
    }

    return NULL;
}

위 함수가 NULL이 아닌 응답을 주었다면, 해당 ssh2_manager 구조체를 통해 명령을 받은 원격 Server에서 메시지가 도착한 것이다. 해당 메시지를 받아보자.

// 역시 별로 코멘트가 필요하지 않다;
int ssh2_result(struct ssh2_manager *stm, char *so_buf, int so_len, char *se_buf, int se_len)
{
    int retval = 0;
    int readlen = 0;

    if ((readlen = libssh2_channel_read(stm->channel, so_buf, so_len)) <= 0) {
        retval = 1;
    } else {
        so_buf[readlen] = '\0';
    }

    if ((readlen = libssh2_channel_read_stderr(stm->channel, se_buf, se_len)) <= 0) {
        retval |= 2;
    } else {
        se_buf[readlen] = '\0';
    }

    return retval;
}

그 밖에 기타등등 함수들을 첨부한다.

int ssh2_shutdown(struct ssh2_manager *stm)
{
    close(stm->sock);
    stm->sock = 0;

    return 0;
}

struct ssh2_poller *ssh2_remove_poller(struct ssh2_poller *stp, struct ssh2_manager *stm)
{
    int i, j;
    struct ssh2_manager *__stm;

    if (stp == NULL) return NULL;

    for (i = 0; i < stp->nfds; i++) {
        if ((stp->pollfds + i)->fd.channel == stm->channel) {
            goto found;
        }
    }
    return NULL;

found:
    for (j = i; j < stp->nfds - 1; j++) {
        memcpy((char *)(stp->pollfds + j), (char *)(stp->pollfds + j + 1), sizeof(LIBSSH2_POLLFD));
    }

    stp->nfds--;

    if (stp->stms == stm) {
        stp->stms = stm->next;
    } else {
        for (__stm = stp->stms; __stm; __stm = __stm->next) {
            if (__stm->next == stm) {
                __stm->next = stm->next;
                goto exit;
            }
        }
    }

exit:
    return stp;
}

마지막으로, 테스트를 위해 사용한 main 펑션을 첨부한다.

int main(int argc, char *argv[])
{
    struct ssh2_manager *stm =
        ssh2_new_manager("192.168.0.100", "ps -ax | grep httpd", NULL);
    int i;

    ssh2_execute(stm);

    struct ssh2_poller *stp = ssh2_new_poller(NULL, stm);

    stm = ssh2_new_manager("192.168.0.101", "ps -ax | grep httpd", NULL);
    ssh2_execute(stm);
    ssh2_new_poller(stp, stm);

    stm = ssh2_new_manager("192.168.0.102", "ps -ax | grep httpd", NULL);
    ssh2_execute(stm);
    ssh2_new_poller(stp, stm);

    while (1) {
        int retval;
        char so_buf[1024], se_buf[1024];

        fprintf(stderr, "NFDS %d =======================\n", stp->nfds);

        if (stp->nfds == 0)
            break;

        retval = ssh2_polling(stp);

        if (retval <= 0) {
            usleep(1000);
            continue;
        }

        while ((stm = ssh2_poller_readable(stp))) {
            if (ssh2_result(stm, so_buf, 1000, se_buf, 1000) != 3) {
                ssh2_remove_poller(stp, stm);
                ssh2_shutdown(stm);
            }

            fprintf(stderr, "NFDS, looping\n");
        }
    }
}

잘 도는지는.. 장담 못한다;

2007/07/04 - [작업로그(SE)/쉘 혹은 명령] - 원격 접속 자동화 (1): rsa 및 dsa key, ssh-agent 사용
2007/07/09 - [작업로그(SE)/쉘 혹은 명령] - 원격 접속 자동화 (2): Script Shell: expect
2007/07/10 - [프로그래밍/Library] - 원격 접속 자동화 (3): libssh
2007/08/07 - [프로그래밍/Library] - 원격 접속 자동화 (3) 추가: libssh2 에서의 *_fromstring