implement.h

很有名的一款用于组织DDoS的恶意机器人程序。仅供研究学习

};


struct ThreadKeyAssoc {
  /*
   * Purpose:
   *	  This structure creates an association between a
   *	  thread and a key.
   *	  It is used to implement the implicit invocation
   *	  of a user defined destroy routine for thread
   *	  specific data registered by a user upon exiting a
   *	  thread.
   *
   * Attributes:
   *	  lock
   *		  protects access to the rest of the structure
   *
   *	  thread
   *		  reference to the thread that owns the association.
   *		  As long as this is not NULL, the association remains
   *		  referenced by the pthread_t.
   *
   *	  key
   *		  reference to the key that owns the association.
   *		  As long as this is not NULL, the association remains
   *		  referenced by the pthread_key_t.
   *
   *	  nextKey
   *		  The pthread_t->keys attribute is the head of a
   *		  chain of associations that runs through the nextKey
   *		  link. This chain provides the 1 to many relationship
   *		  between a pthread_t and all pthread_key_t on which
   *		  it called pthread_setspecific.
   *
   *	  nextThread
   *		  The pthread_key_t->threads attribute is the head of
   *		  a chain of assoctiations that runs through the
   *		  nextThreads link. This chain provides the 1 to many
   *		  relationship between a pthread_key_t and all the 
   *		  PThreads that have called pthread_setspecific for
   *		  this pthread_key_t.
   *
   *
   * Notes:
   *	  1)	  As long as one of the attributes, thread or key, is
   *		  not NULL, the association is being referenced; once
   *		  both are NULL, the association must be released.
   *
   *	  2)	  Under WIN32, an association is only created by
   *		  pthread_setspecific if the user provided a
   *		  destroyRoutine when they created the key.
   *
   *
   */
  pthread_mutex_t lock;
  pthread_t thread;
  pthread_key_t key;
  ThreadKeyAssoc *nextKey;
  ThreadKeyAssoc *nextThread;
};


#ifdef __CLEANUP_SEH
/*
 * --------------------------------------------------------------
 * MAKE_SOFTWARE_EXCEPTION
 *	This macro constructs a software exception code following
 *	the same format as the standard Win32 error codes as defined
 *	in WINERROR.H
 *  Values are 32 bit values layed out as follows:
 *
 *   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 *  +---+-+-+-----------------------+-------------------------------+
 *  |Sev|C|R|	  Facility	    |		    Code	    |
 *  +---+-+-+-----------------------+-------------------------------+
 *
 * Severity Values:
 */
#define SE_SUCCESS		0x00
#define SE_INFORMATION		0x01
#define SE_WARNING		0x02
#define SE_ERROR		0x03

#define MAKE_SOFTWARE_EXCEPTION( _severity, _facility, _exception ) \
( (DWORD) ( ( (_severity) << 30 ) |	/* Severity code	*/ \
	    ( 1 << 29 ) |		/* MS=0, User=1 	*/ \
	    ( 0 << 28 ) |		/* Reserved		*/ \
	    ( (_facility) << 16 ) |	/* Facility Code	*/ \
	    ( (_exception) <<  0 )	/* Exception Code	*/ \
	    ) )

/*
 * We choose one specific Facility/Error code combination to
 * identify our software exceptions vs. WIN32 exceptions.
 * We store our actual component and error code within
 * the optional information array.
 */
#define EXCEPTION_PTW32_SERVICES	\
     MAKE_SOFTWARE_EXCEPTION( SE_ERROR, \
			      PTW32_SERVICES_FACILITY, \
			      PTW32_SERVICES_ERROR )

#define PTW32_SERVICES_FACILITY 	0xBAD
#define PTW32_SERVICES_ERROR		0xDEED

#endif /* __CLEANUP_SEH */

/*
 * Services available through EXCEPTION_PTW32_SERVICES
 * and also used [as parameters to ptw32_throw()] as
 * generic exception selectors.
 */

#define PTW32_EPS_EXIT			(1)
#define PTW32_EPS_CANCEL		(2)

/* Mutex constants */
enum {
  PTW32_MUTEX_LOCK_IDX_INIT	= -1,
  PTW32_MUTEX_OWNER_ANONYMOUS = 1
};


/* Useful macros */
#define PTW32_MAX(a,b)	((a)<(b)?(b):(a))
#define PTW32_MIN(a,b)	((a)>(b)?(b):(a))


/* Declared in global.c */
extern PTW32_INTERLOCKED_LONG (WINAPI *ptw32_interlocked_compare_exchange)(PTW32_INTERLOCKED_LPLONG,
									   PTW32_INTERLOCKED_LONG,
									   PTW32_INTERLOCKED_LONG);

/* Thread Reuse stack bottom marker. Must not be NULL or any valid pointer to memory. */
#define PTW32_THREAD_REUSE_BOTTOM ((pthread_t) 1)

extern int ptw32_processInitialized;
extern pthread_t ptw32_threadReuseTop;
extern pthread_key_t ptw32_selfThreadKey;
extern pthread_key_t ptw32_cleanupKey;
extern pthread_cond_t ptw32_cond_list_head;
extern pthread_cond_t ptw32_cond_list_tail;

extern int ptw32_mutex_default_kind;

extern int ptw32_concurrency;

extern CRITICAL_SECTION ptw32_thread_reuse_lock;
extern CRITICAL_SECTION ptw32_mutex_test_init_lock;
extern CRITICAL_SECTION ptw32_cond_list_lock;
extern CRITICAL_SECTION ptw32_cond_test_init_lock;
extern CRITICAL_SECTION ptw32_rwlock_test_init_lock;
extern CRITICAL_SECTION ptw32_spinlock_test_init_lock;

#ifdef _UWIN
extern int pthread_count;
#endif

/* Declared in misc.c */
#ifdef NEED_CALLOC
#define calloc(n, s) ptw32_calloc(n, s)
void *ptw32_calloc(size_t n, size_t s);
#endif

/* Declared in private.c */
void ptw32_throw(DWORD exception);

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/*
 * =====================
 * =====================
 * Forward Declarations
 * =====================
 * =====================
 */

int ptw32_is_attr (const pthread_attr_t *attr);

int ptw32_cond_check_need_init(pthread_cond_t *cond);
int ptw32_mutex_check_need_init(pthread_mutex_t *mutex);
int ptw32_rwlock_check_need_init(pthread_rwlock_t *rwlock);

PTW32_INTERLOCKED_LONG WINAPI
ptw32_InterlockedCompareExchange(PTW32_INTERLOCKED_LPLONG location,
				 PTW32_INTERLOCKED_LONG   value,
				 PTW32_INTERLOCKED_LONG   comparand);

int ptw32_processInitialize (void);

void ptw32_processTerminate (void);

void ptw32_threadDestroy (pthread_t tid);

void ptw32_pop_cleanup_all (int execute);

pthread_t ptw32_new (void);

pthread_t ptw32_threadReusePop (void);

void ptw32_threadReusePush (pthread_t thread);

int ptw32_getprocessors (int * count);

int ptw32_setthreadpriority (pthread_t thread,
                             int policy,
                             int priority);

#if ! defined (__MINGW32__) || defined (__MSVCRT__)
unsigned __stdcall
#else
void
#endif
ptw32_threadStart (void * vthreadParms);

void ptw32_callUserDestroyRoutines (pthread_t thread);

int ptw32_tkAssocCreate (ThreadKeyAssoc ** assocP,
			    pthread_t thread,
			    pthread_key_t key);

void ptw32_tkAssocDestroy (ThreadKeyAssoc * assoc);


#ifdef NEED_SEM
void ptw32_decrease_semaphore(sem_t * sem);
BOOL ptw32_increase_semaphore(sem_t * sem,
				 unsigned int n);
#endif /* NEED_SEM */

#ifdef NEED_FTIME
void ptw32_timespec_to_filetime(const struct timespec *ts, FILETIME *ft);
void ptw32_filetime_to_timespec(const FILETIME *ft, struct timespec *ts);
#endif

#ifdef __cplusplus
}
#endif /* __cplusplus */


#ifdef _UWIN_
#   ifdef	_MT
#	ifdef __cplusplus
	extern "C" {
#	endif
	_CRTIMP unsigned long  __cdecl _beginthread (void (__cdecl *) (void *),
		unsigned, void *);
	_CRTIMP void __cdecl _endthread(void);
	_CRTIMP unsigned long __cdecl _beginthreadex(void *, unsigned,
		unsigned (__stdcall *) (void *), void *, unsigned, unsigned *);
	_CRTIMP void __cdecl _endthreadex(unsigned);
#	ifdef __cplusplus
	}
#	endif
#   endif
#else
#   include <process.h>
#endif

/*
 * Check for old and new versions of cygwin. See the FAQ file:
 *
 * Question 1 - How do I get pthreads-win32 to link under Cygwin or Mingw32?
 *
 * Patch by Anders Norlander <[e-mail]>
 */
#if defined(__CYGWIN32__) || defined(__CYGWIN__) || defined(NEED_CREATETHREAD)

/* 
 * Macro uses args so we can cast start_proc to LPTHREAD_START_ROUTINE
 * in order to avoid warnings because of return type
 */

#define _beginthreadex(security, \
		       stack_size, \
		       start_proc, \
		       arg, \
		       flags, \
		       pid) \
	CreateThread(security, \
		     stack_size, \
		     (LPTHREAD_START_ROUTINE) start_proc, \
		     arg, \
		     flags, \
		     pid)

#define _endthreadex ExitThread

#endif /* __CYGWIN32__ || __CYGWIN__ || NEED_CREATETHREAD*/


#endif /* _IMPLEMENT_H */