samba-mirror/source3/libsmb/libsmb_thread_impl.c

/* 
   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);
}