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
|
/*
Unix SMB/Netbios implementation.
SMB client library implementation
Copyright (C) Derrell Lipman 2009
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "libsmbclient.h"
#include "libsmb_internal.h"
/**
* Initialize for an arbitrary thread implementation. The caller should
* provide, as parameters, pointers to functions to implement the requisite
* low-level thread functionality. A function must be provided for each
* parameter; none may be null.
*
* If the thread implementation is POSIX Threads (pthreads), then the much
* simpler smbc_thread_pthread() function may be used instead of this one.
*
* @param create_mutex
* Create a mutex. This function should expect three parameters: lockname,
* pplock, and location. It should create a unique mutex for each unique
* lockname it is provided, and return the mutex identifier in *pplock. The
* location parameter can be used for debugging, as it contains the
* compiler-provided __location__ of the call.
*
* @param destroy_mutex
* Destroy a mutex. This function should expect two parameters: plock and
* location. It should destroy the mutex associated with the identifier
* plock. The location parameter can be used for debugging, as it contains
* the compiler-provided __location__ of the call.
*
* @param lock_mutex
* Lock a mutex. This function should expect three parameters: plock,
* lock_type, and location. The mutex aassociated with identifier plock
* should be locked if lock_type is 1, and unlocked if lock_type is 2. The
* location parameter can be used for debugging, as it contains the
* compiler-provided __location__ of the call.
*
* @param create_tls
* Create thread local storage. This function should expect three
* parameters: keyname, ppkey, and location. It should allocate an
* implementation-specific amount of memory and assign the pointer to that
* allocated memory to *ppkey. The location parameter can be used for
* debugging, as it contains the compiler-provided __location__ of the
* call. This function should return 0 upon success, non-zero upon failure.
*
* @param destroy_tls
* Destroy thread local storage. This function should expect two parameters:
* ppkey and location. The ppkey parameter points to a variable containing a
* thread local storage key previously provided by the create_tls
* function. The location parameter can be used for debugging, as it
* contains the compiler-provided __location__ of the call.
*
* @param set_tls
* Set a thread local storage variable's value. This function should expect
* three parameters: pkey, pval, and location. The pkey parameter is a
* thread local storage key previously provided by the create_tls
* function. The (void *) pval parameter contains the value to be placed in
* the thread local storage variable identified by pkey. The location
* parameter can be used for debugging, as it contains the compiler-provided
* __location__ of the call. This function should return 0 upon success;
* non-zero otherwise.
*
* @param get_tls
* Retrieve a thread local storage variable's value. This function should
* expect two parameters: pkey and location. The pkey parameter is a thread
* local storage key previously provided by the create_tls function, and
* which has previously been used in a call to the set_tls function to
* initialize a thread local storage variable. The location parameter can be
* used for debugging, as it contains the compiler-provided __location__ of
* the call. This function should return the (void *) value stored in the
* variable identified by pkey.
*
* @return {void}
*/
void
smbc_thread_impl(
/* Mutex functions. */
int (*create_mutex)(const char *lockname,
void **pplock,
const char *location),
void (*destroy_mutex)(void *plock,
const char *location),
int (*lock_mutex)(void *plock,
int lock_type,
const char *location),
/* Thread local storage. */
int (*create_tls)(const char *keyname,
void **ppkey,
const char *location),
void (*destroy_tls)(void **ppkey,
const char *location),
int (*set_tls)(void *pkey,
const void *pval,
const char *location),
void *(*get_tls)(void *pkey,
const char *location)
)
{
static struct smb_thread_functions tf;
tf.create_mutex = create_mutex;
tf.destroy_mutex = destroy_mutex;
tf.lock_mutex = lock_mutex;
tf.create_tls = create_tls;
tf.destroy_tls = destroy_tls;
tf.set_tls = set_tls;
tf.get_tls = get_tls;
smb_thread_set_functions(&tf);
}
|
