← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to win32/3rdparty/pthreads/pthread_setspecific.c

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
win32/3rdparty/pthreads/pthread_setspecific.c
1
 
/*
2
 
 * pthread_setspecific.c
3
 
 *
4
 
 * Description:
5
 
 * POSIX thread functions which implement thread-specific data (TSD).
6
 
 *
7
 
 * --------------------------------------------------------------------------
8
 
 *
9
 
 *      Pthreads-win32 - POSIX Threads Library for Win32
10
 
 *      Copyright(C) 1998 John E. Bossom
11
 
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
12
 
 * 
13
 
 *      Contact Email: rpj@callisto.canberra.edu.au
14
 
 * 
15
 
 *      The current list of contributors is contained
16
 
 *      in the file CONTRIBUTORS included with the source
17
 
 *      code distribution. The list can also be seen at the
18
 
 *      following World Wide Web location:
19
 
 *      http://sources.redhat.com/pthreads-win32/contributors.html
20
 
 * 
21
 
 *      This library is free software; you can redistribute it and/or
22
 
 *      modify it under the terms of the GNU Lesser General Public
23
 
 *      License as published by the Free Software Foundation; either
24
 
 *      version 2 of the License, or (at your option) any later version.
25
 
 * 
26
 
 *      This library is distributed in the hope that it will be useful,
27
 
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
28
 
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
29
 
 *      Lesser General Public License for more details.
30
 
 * 
31
 
 *      You should have received a copy of the GNU Lesser General Public
32
 
 *      License along with this library in the file COPYING.LIB;
33
 
 *      if not, write to the Free Software Foundation, Inc.,
34
 
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
35
 
 */
36
 
 
37
 
#include "pthread.h"
38
 
#include "implement.h"
39
 
 
40
 
 
41
 
int
42
 
pthread_setspecific (pthread_key_t key, const void *value)
43
 
     /*
44
 
      * ------------------------------------------------------
45
 
      * DOCPUBLIC
46
 
      *      This function sets the value of the thread specific
47
 
      *      key in the calling thread.
48
 
      *
49
 
      * PARAMETERS
50
 
      *      key
51
 
      *              an instance of pthread_key_t
52
 
      *      value
53
 
      *              the value to set key to
54
 
      *
55
 
      *
56
 
      * DESCRIPTION
57
 
      *      This function sets the value of the thread specific
58
 
      *      key in the calling thread.
59
 
      *
60
 
      * RESULTS
61
 
      *              0               successfully set value
62
 
      *              EAGAIN          could not set value
63
 
      *              ENOENT          SERIOUS!!
64
 
      *
65
 
      * ------------------------------------------------------
66
 
      */
67
 
{
68
 
  pthread_t self;
69
 
  int result = 0;
70
 
 
71
 
  if (key != ptw32_selfThreadKey)
72
 
    {
73
 
      /*
74
 
       * Using pthread_self will implicitly create
75
 
       * an instance of pthread_t for the current
76
 
       * thread if one wasn't explicitly created
77
 
       */
78
 
      self = pthread_self ();
79
 
      if (self.p == NULL)
80
 
        {
81
 
          return ENOENT;
82
 
        }
83
 
    }
84
 
  else
85
 
    {
86
 
      /*
87
 
       * Resolve catch-22 of registering thread with selfThread
88
 
       * key
89
 
       */
90
 
      ptw32_thread_t * sp = (ptw32_thread_t *) pthread_getspecific (ptw32_selfThreadKey);
91
 
 
92
 
      if (sp == NULL)
93
 
        {
94
 
          if (value == NULL)
95
 
            {
96
 
              return ENOENT;
97
 
            }
98
 
          self = *((pthread_t *) value);
99
 
        }
100
 
      else
101
 
        {
102
 
          self = sp->ptHandle;
103
 
        }
104
 
    }
105
 
 
106
 
  result = 0;
107
 
 
108
 
  if (key != NULL)
109
 
    {
110
 
      if (self.p != NULL && key->destructor != NULL && value != NULL)
111
 
        {
112
 
          /*
113
 
           * Only require associations if we have to
114
 
           * call user destroy routine.
115
 
           * Don't need to locate an existing association
116
 
           * when setting data to NULL for WIN32 since the
117
 
           * data is stored with the operating system; not
118
 
           * on the association; setting assoc to NULL short
119
 
           * circuits the search.
120
 
           */
121
 
          ThreadKeyAssoc *assoc;
122
 
 
123
 
          if (pthread_mutex_lock(&(key->keyLock)) == 0)
124
 
            {
125
 
              ptw32_thread_t * sp = (ptw32_thread_t *) self.p;
126
 
 
127
 
              (void) pthread_mutex_lock(&(sp->threadLock));
128
 
 
129
 
              assoc = (ThreadKeyAssoc *) sp->keys;
130
 
              /*
131
 
               * Locate existing association
132
 
               */
133
 
              while (assoc != NULL)
134
 
                {
135
 
                  if (assoc->key == key)
136
 
                    {
137
 
                      /*
138
 
                       * Association already exists
139
 
                       */
140
 
                      break;
141
 
                    }
142
 
                  assoc = assoc->nextKey;
143
 
                }
144
 
 
145
 
              /*
146
 
               * create an association if not found
147
 
               */
148
 
              if (assoc == NULL)
149
 
                {
150
 
                  result = ptw32_tkAssocCreate (sp, key);
151
 
                }
152
 
 
153
 
              (void) pthread_mutex_unlock(&(sp->threadLock));
154
 
            }
155
 
          (void) pthread_mutex_unlock(&(key->keyLock));
156
 
        }
157
 
 
158
 
      if (result == 0)
159
 
        {
160
 
          if (!TlsSetValue (key->key, (LPVOID) value))
161
 
            {
162
 
              result = EAGAIN;
163
 
            }
164
 
        }
165
 
    }
166
 
 
167
 
  return (result);
168
 
}                               /* pthread_setspecific */