implement.h

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

/*
 * implement.h
 *
 * Definitions that don't need to be public.
 *
 * Keeps all the internals out of pthread.h
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2003 Pthreads-win32 contributors
 * 
 *      Contact Email: [e-mail]
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This 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 of the License, or (at your option) any later version.
 * 
 *      This 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 this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#ifndef _IMPLEMENT_H
#define _IMPLEMENT_H

/*
 * note: ETIMEDOUT is correctly defined in winsock.h
 */
#include <windows.h>
#include <winsock.h>

/*
 * In case ETIMEDOUT hasn't been defined above somehow.
 */
#ifndef ETIMEDOUT
#  define ETIMEDOUT 10060     /* This is the value in winsock.h. */
#endif

#if !defined(malloc)
#include <malloc.h>
#endif

#if !defined(INT_MAX)
#include <limits.h>
#endif

/* use local include files during development */
#include "semaphore.h"
#include "sched.h"

#if defined(HAVE_C_INLINE) || defined(__cplusplus)
#define INLINE inline
#else
#define INLINE
#endif

#if defined (__MINGW32__) || (_MSC_VER >= 1300)
#define PTW32_INTERLOCKED_LONG long
#define PTW32_INTERLOCKED_LPLONG long*
#else
#define PTW32_INTERLOCKED_LONG PVOID
#define PTW32_INTERLOCKED_LPLONG PVOID*
#endif

typedef enum {
  /*
   * This enumeration represents the state of the thread;
   * The thread is still "alive" if the numeric value of the
   * state is greater or equal "PThreadStateRunning".
   */
  PThreadStateInitial = 0,	/* Thread not running			*/
  PThreadStateRunning,		/* Thread alive & kicking		*/
  PThreadStateSuspended,	/* Thread alive but suspended		*/
  PThreadStateCanceling,	/* Thread alive but is                  */
				/* in the process of terminating	*/
				/* due to a cancellation request	*/
  PThreadStateException,	/* Thread alive but exiting		*/
				/* due to an exception			*/
  PThreadStateLast
}
PThreadState;


typedef enum {
  /*
   * This enumeration represents the reason why a thread has
   * terminated/is terminating.
   */
  PThreadDemisePeaceful = 0,	/* Death due natural causes	*/
  PThreadDemiseCancelled,	/* Death due to user cancel	*/
  PThreadDemiseException,	/* Death due to unhandled	*/
				/* exception			*/
  PThreadDemiseNotDead	/* I'm not dead!		*/
}
PThreadDemise;

struct pthread_t_ {
#ifdef _UWIN
  DWORD dummy[5];
#endif
  DWORD thread;
  HANDLE threadH;             /* POSIX thread is invalid if threadH == 0 */
  pthread_t prevReuse;        /* Links threads on reuse stack */
  PThreadState state;
  PThreadDemise demise;
  void *exitStatus;
  void *parms;
  int ptErrno;
  int detachState;
  pthread_mutex_t threadLock;  /* Used for serialised access to public thread state */
  int sched_priority;          /* As set, not as currently is */
  pthread_mutex_t cancelLock;  /* Used for async-cancel safety */
  int cancelState;
  int cancelType;
  HANDLE cancelEvent;
#ifdef __CLEANUP_C
  jmp_buf start_mark;
#endif /* __CLEANUP_C */
#if HAVE_SIGSET_T
  sigset_t sigmask;
#endif /* HAVE_SIGSET_T */
  int implicit:1;
  void *keys;
};


/* 
 * Special value to mark attribute objects as valid.
 */
#define PTW32_ATTR_VALID ((unsigned long) 0xC4C0FFEE)

struct pthread_attr_t_ {
  unsigned long valid;
  void *stackaddr;
  size_t stacksize;
  int detachstate;
  struct sched_param param;
  int inheritsched;
  int contentionscope;
#if HAVE_SIGSET_T
  sigset_t sigmask;
#endif /* HAVE_SIGSET_T */
};


/*
 * ====================
 * ====================
 * Semaphores, Mutexes and Condition Variables
 * ====================
 * ====================
 */

struct sem_t_ {
#ifdef NEED_SEM
  unsigned int	value;
  CRITICAL_SECTION sem_lock_cs;
  HANDLE	event;
#else /* NEED_SEM */
  HANDLE sem;
#endif /* NEED_SEM */
};

#define PTW32_OBJECT_AUTO_INIT ((void *) -1)
#define PTW32_OBJECT_INVALID   NULL

struct pthread_mutex_t_ {
  LONG lock_idx;	       /* Provides exclusive access to mutex state
				  via the Interlocked* mechanism, as well
				  as a count of the number of threads
				  waiting on the mutex. */
  int recursive_count;	       /* Number of unlocks a thread needs to perform
				  before the lock is released (recursive
				  mutexes only). */
  int kind;		       /* Mutex type. */
  pthread_t ownerThread;
  sem_t wait_sema;	       /* Mutex release notification to waiting
				  threads. */
  CRITICAL_SECTION wait_cs;    /* Serialise lock_idx decrement after mutex
				  timeout. */
};

struct pthread_mutexattr_t_ {
  int pshared;
  int kind;
};

/*
 * Possible values, other than PTW32_OBJECT_INVALID,
 * for the "interlock" element in a spinlock.
 *
 * In this implementation, when a spinlock is initialised,
 * the number of cpus available to the process is checked.
 * If there is only one cpu then "interlock" is set equal to
 * PTW32_SPIN_USE_MUTEX and u.mutex is a initialised mutex.
 * If the number of cpus is greater than 1 then "interlock"
 * is set equal to PTW32_SPIN_UNLOCKED and the number is
 * stored in u.cpus. This arrangement allows the spinlock
 * routines to attempt an InterlockedCompareExchange on "interlock"
 * immediately and, if that fails, to try the inferior mutex.
 *
 * "u.cpus" isn't used for anything yet, but could be used at
 * some point to optimise spinlock behaviour.
 */
#define PTW32_SPIN_UNLOCKED    (1)
#define PTW32_SPIN_LOCKED      (2)
#define PTW32_SPIN_USE_MUTEX   (3)

struct pthread_spinlock_t_ {
  long interlock;	       /* Locking element for multi-cpus. */
  union {
    int cpus;		       /* No. of cpus if multi cpus, or   */
    pthread_mutex_t mutex;     /* mutex if single cpu.		  */
  } u;
};

struct pthread_barrier_t_ {
  unsigned int nCurrentBarrierHeight;
  unsigned int nInitialBarrierHeight;
  int iStep;
  int pshared;
  sem_t semBarrierBreeched[2];
};

struct pthread_barrierattr_t_ {
  int pshared;
};

struct pthread_key_t_ {
  DWORD key;
  void (*destructor) (void *);
  pthread_mutex_t threadsLock;
  void *threads;
};


typedef struct ThreadParms ThreadParms;
typedef struct ThreadKeyAssoc ThreadKeyAssoc;

struct ThreadParms {
  pthread_t tid;
  void *(*start) (void *);
  void *arg;
};


struct pthread_cond_t_ {
  long		  nWaitersBlocked;   /* Number of threads blocked	     */
  long		  nWaitersGone;      /* Number of threads timed out	     */
  long		  nWaitersToUnblock; /* Number of threads to unblock	     */
  sem_t 	  semBlockQueue;     /* Queue up threads waiting for the     */
				     /*   condition to become signalled      */
  sem_t 	  semBlockLock;      /* Semaphore that guards access to      */
				     /* | waiters blocked count/block queue  */
				     /* +-> Mandatory Sync.LEVEL-1	     */
  pthread_mutex_t mtxUnblockLock;    /* Mutex that guards access to	     */
				     /* | waiters (to)unblock(ed) counts     */
				     /* +-> Optional* Sync.LEVEL-2	     */
  pthread_cond_t next;		     /* Doubly linked list		     */
  pthread_cond_t prev;
};


struct pthread_condattr_t_ {
  int pshared;
};

#define PTW32_RWLOCK_MAGIC 0xfacade2

struct pthread_rwlock_t_ {
  pthread_mutex_t   mtxExclusiveAccess;
  pthread_mutex_t   mtxSharedAccessCompleted;
  pthread_cond_t    cndSharedAccessCompleted;
  int		    nSharedAccessCount;
  int		    nExclusiveAccessCount;
  int		    nCompletedSharedAccessCount;
  int		    nMagic;
};

struct pthread_rwlockattr_t_ {
  int		    pshared;