libssh-rs-sys 0.2.6

Native bindings to the libssh library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

/*
 * This file is part of the SSH Library
 *
 * Copyright (c) 2010 by Aris Adamantiadis
 *
 * 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"
#include "libssh/threads.h"
#include <libssh/callbacks.h>

#include <errno.h>
#include <stdlib.h>
#include <pthread.h>

static int ssh_pthread_mutex_init (void **mutex)
{
    int rc = 0;

    if (mutex == NULL) {
        return EINVAL;
    }

    *mutex = malloc(sizeof(pthread_mutex_t));
    if (*mutex == NULL) {
        return ENOMEM;
    }

    rc = pthread_mutex_init ((pthread_mutex_t *)*mutex, NULL);
    if (rc){
        free (*mutex);
        *mutex = NULL;
    }

    return rc;
}

static int ssh_pthread_mutex_destroy (void **mutex)
{

    int rc = 0;

    if (mutex == NULL) {
        return EINVAL;
    }

    rc = pthread_mutex_destroy ((pthread_mutex_t *)*mutex);

    free (*mutex);
    *mutex = NULL;

    return rc;
}

static int ssh_pthread_mutex_lock (void **mutex)
{
    return pthread_mutex_lock((pthread_mutex_t *)*mutex);
}

static int ssh_pthread_mutex_unlock (void **mutex)
{
    return pthread_mutex_unlock((pthread_mutex_t *)*mutex);
}

static unsigned long ssh_pthread_thread_id (void)
{
#if defined(_WIN32) && !defined(__WINPTHREADS_VERSION)
    return (unsigned long) pthread_self().p;
#else
    return (unsigned long) pthread_self();
#endif
}

static struct ssh_threads_callbacks_struct ssh_threads_pthread =
{
    .type = "threads_pthread",
    .mutex_init = ssh_pthread_mutex_init,
    .mutex_destroy = ssh_pthread_mutex_destroy,
    .mutex_lock = ssh_pthread_mutex_lock,
    .mutex_unlock = ssh_pthread_mutex_unlock,
    .thread_id = ssh_pthread_thread_id
};

/* Threads interface implementation */

#if (HAVE_PTHREAD)
void ssh_mutex_lock(SSH_MUTEX *mutex)
{
    int rc;

    if (mutex == NULL) {
        exit(EINVAL);
    }

    rc = pthread_mutex_lock(mutex);

    if (rc) {
        exit(rc);
    }
}

void ssh_mutex_unlock(SSH_MUTEX *mutex)
{
    int rc;

    if (mutex == NULL) {
        exit(EINVAL);
    }

    rc = pthread_mutex_unlock(mutex);

    if (rc) {
        exit(rc);
    }
}

struct ssh_threads_callbacks_struct *ssh_threads_get_default(void)
{
    return &ssh_threads_pthread;
}
#endif

struct ssh_threads_callbacks_struct *ssh_threads_get_pthread(void)
{
    return &ssh_threads_pthread;
}