deleted file mode 100644

@@ -1,87 +0,0 @@

-/*

- *

- * Copyright (C) 2001-2003 FhG Fokus

- *

- * This file is part of Kamailio, a free SIP server.

- *

- * Kamailio 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 2 of the License, or

- * (at your option) any later version

- *

- * Kamailio 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, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

- */

-

-/*!

-* \file

-* \brief Kamailio core :: Kamailio locking library

-* \ingroup core

-* \author andrei

-* Module: \ref core

- *

- *

-Implements (in lock_ops.h & lock_alloc.h):

-

-	simple locks:

-	-------------

-	type: gen_lock_t

-	gen_lock_t* lock_alloc();                - allocates a lock in shared mem.

-	gen_lock_t* lock_init(gen_lock_t* lock); - inits the lock

-	void    lock_destroy(gen_lock_t* lock);  - removes the lock (e.g sysv rmid)

-	void    lock_dealloc(gen_lock_t* lock);  - deallocates the lock's shared m.

-	void    lock_get(gen_lock_t* lock);      - lock (mutex down)

-	void    lock_release(gen_lock_t* lock);  - unlock (mutex up)

-

-	lock sets:

-	----------

-	type: gen_lock_set_t

-	gen_lock_set_t* lock_set_alloc(no)               - allocs a lock set in shm.

-	gen_lock_set_t* lock_set_init(gen_lock_set_t* set);  - inits the lock set

-	void lock_set_destroy(gen_lock_set_t* s);        - removes the lock set

-	void lock_set_dealloc(gen_lock_set_t* s);        - deallocs the lock set shm.

-	void lock_set_get(gen_lock_set_t* s, int i);     - locks sem i from the set

-	void lock_set_release(gen_lock_set_t* s, int i)  - unlocks sem i from the set

-

-	recursive locks:

-	-------------

-	type: rec_lock_t

-	rec_lock_t* rec_lock_alloc();                - allocates a lock in shared mem.

-	rec_lock_t* rec_lock_init(rec_lock_t* lock); - inits the lock

-	void    rec_lock_destroy(rec_lock_t* lock);  - removes the lock (e.g sysv rmid)

-	void    rec_lock_dealloc(rec_lock_t* lock);  - deallocates the lock's shared m.

-	void    rec_lock_get(rec_lock_t* lock);      - lock (mutex down)

-	void    rec_lock_release(rec_lock_t* lock);  - unlock (mutex up)

-

-WARNING: - lock_set_init may fail for large number of sems (e.g. sysv).

-         - signals are not treated! (some locks are "awakened" by the signals)

-*/

-

-#ifndef _locking_h

-#define _locking_h

-

-/* the order is important */

-#include "lock_ops.h"

-#include "lock_alloc.h"

-#include "atomic_ops.h"

-

-typedef struct rec_lock {

-	gen_lock_t lock;     /* mutex to access items in the slot */

-	atomic_t locker_pid; /* pid of the process that holds the lock */

-	int rec_lock_level;  /* recursive lock count */

-} rec_lock_t;

-

-rec_lock_t* rec_lock_alloc();

-rec_lock_t* rec_lock_init(rec_lock_t* lock);

-void rec_lock_destroy(rec_lock_t* lock);

-void rec_lock_dealloc(rec_lock_t* lock);

-void rec_lock_get(rec_lock_t* lock);

-void rec_lock_release(rec_lock_t* lock);

-

-#endif

@@ -14,8 +14,8 @@

  * 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, write to the Free Software 

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

  */

@@ -38,7 +38,7 @@ Implements (in lock_ops.h & lock_alloc.h):

 	void    lock_dealloc(gen_lock_t* lock);  - deallocates the lock's shared m.

 	void    lock_get(gen_lock_t* lock);      - lock (mutex down)

 	void    lock_release(gen_lock_t* lock);  - unlock (mutex up)

-	

+

 	lock sets:

 	----------

 	type: gen_lock_set_t

@@ -49,7 +49,17 @@ Implements (in lock_ops.h & lock_alloc.h):

 	void lock_set_get(gen_lock_set_t* s, int i);     - locks sem i from the set

 	void lock_set_release(gen_lock_set_t* s, int i)  - unlocks sem i from the set

-WARNING: - lock_set_init may fail for large number of sems (e.g. sysv). 

+	recursive locks:

+	-------------

+	type: rec_lock_t

+	rec_lock_t* rec_lock_alloc();                - allocates a lock in shared mem.

+	rec_lock_t* rec_lock_init(rec_lock_t* lock); - inits the lock

+	void    rec_lock_destroy(rec_lock_t* lock);  - removes the lock (e.g sysv rmid)

+	void    rec_lock_dealloc(rec_lock_t* lock);  - deallocates the lock's shared m.

+	void    rec_lock_get(rec_lock_t* lock);      - lock (mutex down)

+	void    rec_lock_release(rec_lock_t* lock);  - unlock (mutex up)

+

+WARNING: - lock_set_init may fail for large number of sems (e.g. sysv).

          - signals are not treated! (some locks are "awakened" by the signals)

 */

@@ -58,6 +68,20 @@ WARNING: - lock_set_init may fail for large number of sems (e.g. sysv).

 /* the order is important */

 #include "lock_ops.h"

-#include "lock_alloc.h" 

+#include "lock_alloc.h"

+#include "atomic_ops.h"

+

+typedef struct rec_lock {

+	gen_lock_t lock;     /* mutex to access items in the slot */

+	atomic_t locker_pid; /* pid of the process that holds the lock */

+	int rec_lock_level;  /* recursive lock count */

+} rec_lock_t;

+

+rec_lock_t* rec_lock_alloc();

+rec_lock_t* rec_lock_init(rec_lock_t* lock);

+void rec_lock_destroy(rec_lock_t* lock);

+void rec_lock_dealloc(rec_lock_t* lock);

+void rec_lock_get(rec_lock_t* lock);

+void rec_lock_release(rec_lock_t* lock);

 #endif

@@ -1,21 +1,15 @@

-/* $Id$ */

 /*

  *

  * Copyright (C) 2001-2003 FhG Fokus

  *

- * This file is part of ser, a free SIP server.

+ * This file is part of Kamailio, a free SIP server.

  *

- * ser is free software; you can redistribute it and/or modify

+ * Kamailio 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 2 of the License, or

  * (at your option) any later version

  *

- * For a license to use the ser software under conditions

- * other than those described here, or to purchase support for this

- * software, please contact iptel.org by e-mail at the following addresses:

- *    info@iptel.org

- *

- * ser is distributed in the hope that it will be useful,

+ * Kamailio 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.

@@ -25,17 +19,13 @@

  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

  */

-/*

- *   ser locking library

+/*!

+* \file

+* \brief Kamailio core :: Kamailio locking library

+* \ingroup core

+* \author andrei

+* Module: \ref core

  *

- *  2002-12-16  created by andrei

- *  2003-02-20  s/gen_lock_t/gen_lock_t/ to avoid a type conflict 

- *               on solaris  (andrei)

- *  2003-03-05  lock set support added for FAST_LOCK & SYSV (andrei)

- *  2003-03-06  split in two: lock_ops.h & lock_alloc.h, to avoid

- *               shm_mem.h<->locking.h interdependency (andrei)

- *  2004-07-28  s/lock_set_t/gen_lock_set_t/ because of a type conflict

- *              on darwin (andrei)

  *

 Implements (in lock_ops.h & lock_alloc.h):

@@ -22,7 +22,7 @@

  *

  * You should have received a copy of the GNU General Public License 

  * along with this program; if not, write to the Free Software 

- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

  */

 /*

@@ -1,7 +1,7 @@

 /* $Id$ */

 /*

  *

- * Copyright (C) 2001-2003 Fhg Fokus

+ * Copyright (C) 2001-2003 FhG Fokus

  *

  * This file is part of ser, a free SIP server.

  *

@@ -32,7 +32,7 @@

  *  2003-02-20  s/gen_lock_t/gen_lock_t/ to avoid a type conflict 

  *               on solaris  (andrei)

  *  2003-03-05  lock set support added for FAST_LOCK & SYSV (andrei)

- *  2003-03-06  splited in two: lock_ops.h & lock_alloc.h, to avoid

+ *  2003-03-06  split in two: lock_ops.h & lock_alloc.h, to avoid

  *               shm_mem.h<->locking.h interdependency (andrei)

  *  2004-07-28  s/lock_set_t/gen_lock_set_t/ because of a type conflict

  *              on darwin (andrei)

@@ -34,6 +34,8 @@

  *  2003-03-05  lock set support added for FAST_LOCK & SYSV (andrei)

  *  2003-03-06  splited in two: lock_ops.h & lock_alloc.h, to avoid

  *               shm_mem.h<->locking.h interdependency (andrei)

+ *  2004-07-28  s/lock_set_t/gen_lock_set_t/ because of a type conflict

+ *              on darwin (andrei)

  *

 Implements (in lock_ops.h & lock_alloc.h):

@@ -49,13 +51,13 @@ Implements (in lock_ops.h & lock_alloc.h):

 	lock sets:

 	----------

-	type: lock_set_t

-	lock_set_t* lock_set_alloc(no)               - allocs a lock set in shm.

-	lock_set_t* lock_set_init(lock_set_t* set);  - inits the lock set

-	void lock_set_destroy(lock_set_t* s);        - removes the lock set

-	void lock_set_dealloc(lock_set_t* s);        - deallocs the lock set shm.

-	void lock_set_get(lock_set_t* s, int i);     - locks sem i from the set

-	void lock_set_release(lock_set_t* s, int i)  - unlocks sem i from the set

+	type: gen_lock_set_t

+	gen_lock_set_t* lock_set_alloc(no)               - allocs a lock set in shm.

+	gen_lock_set_t* lock_set_init(gen_lock_set_t* set);  - inits the lock set

+	void lock_set_destroy(gen_lock_set_t* s);        - removes the lock set

+	void lock_set_dealloc(gen_lock_set_t* s);        - deallocs the lock set shm.

+	void lock_set_get(gen_lock_set_t* s, int i);     - locks sem i from the set

+	void lock_set_release(gen_lock_set_t* s, int i)  - unlocks sem i from the set

 WARNING: - lock_set_init may fail for large number of sems (e.g. sysv). 

          - signals are not treated! (some locks are "awakened" by the signals)

@@ -57,7 +57,8 @@ Implements (in lock_ops.h & lock_alloc.h):

 	void lock_set_get(lock_set_t* s, int i);     - locks sem i from the set

 	void lock_set_release(lock_set_t* s, int i)  - unlocks sem i from the set

-WARNING: signals are not treated! (some locks are "awakened" by the signals)

+WARNING: - lock_set_init may fail for large number of sems (e.g. sysv). 

+         - signals are not treated! (some locks are "awakened" by the signals)

 */

 #ifndef _locking_h

@@ -39,6 +39,7 @@ Implements (in lock_ops.h & lock_alloc.h):

 	simple locks:

 	-------------

+	type: gen_lock_t

 	gen_lock_t* lock_alloc();                - allocates a lock in shared mem.

 	gen_lock_t* lock_init(gen_lock_t* lock); - inits the lock

 	void    lock_destroy(gen_lock_t* lock);  - removes the lock (e.g sysv rmid)

@@ -46,8 +47,9 @@ Implements (in lock_ops.h & lock_alloc.h):

 	void    lock_get(gen_lock_t* lock);      - lock (mutex down)

 	void    lock_release(gen_lock_t* lock);  - unlock (mutex up)

-	lock sets: [implemented only for FL & SYSV so far]

+	lock sets:

 	----------

+	type: lock_set_t

 	lock_set_t* lock_set_alloc(no)               - allocs a lock set in shm.

 	lock_set_t* lock_set_init(lock_set_t* set);  - inits the lock set

 	void lock_set_destroy(lock_set_t* s);        - removes the lock set

@@ -31,155 +31,38 @@

  *  2002-12-16  created by andrei

  *  2003-02-20  s/gen_lock_t/gen_lock_t/ to avoid a type conflict 

  *               on solaris  (andrei)

+ *  2003-03-05  lock set support added for FAST_LOCK & SYSV (andrei)

+ *  2003-03-06  splited in two: lock_ops.h & lock_alloc.h, to avoid

+ *               shm_mem.h<->locking.h interdependency (andrei)

  *

-Implements:

-

-	gen_lock_t* lock_alloc();               - allocates a lock in shared mem.

-	gen_lock_t* lock_init(gen_lock_t* lock);    - inits the lock

-	void    lock_destroy(gen_lock_t* lock); - removes the lock (e.g sysv rmid)

-	void    lock_dealloc(gen_lock_t* lock); - deallocates the lock's shared m.

-	void    lock_get(gen_lock_t* lock);     - lock (mutex down)

-	void    lock_release(gen_lock_t* lock); - unlock (mutex up)

+Implements (in lock_ops.h & lock_alloc.h):

+

+	simple locks:

+	-------------

+	gen_lock_t* lock_alloc();                - allocates a lock in shared mem.

+	gen_lock_t* lock_init(gen_lock_t* lock); - inits the lock

+	void    lock_destroy(gen_lock_t* lock);  - removes the lock (e.g sysv rmid)

+	void    lock_dealloc(gen_lock_t* lock);  - deallocates the lock's shared m.

+	void    lock_get(gen_lock_t* lock);      - lock (mutex down)

+	void    lock_release(gen_lock_t* lock);  - unlock (mutex up)

+	

+	lock sets: [implemented only for FL & SYSV so far]

+	----------

+	lock_set_t* lock_set_alloc(no)               - allocs a lock set in shm.

+	lock_set_t* lock_set_init(lock_set_t* set);  - inits the lock set

+	void lock_set_destroy(lock_set_t* s);        - removes the lock set

+	void lock_set_dealloc(lock_set_t* s);        - deallocs the lock set shm.

+	void lock_set_get(lock_set_t* s, int i);     - locks sem i from the set

+	void lock_set_release(lock_set_t* s, int i)  - unlocks sem i from the set

+

+WARNING: signals are not treated! (some locks are "awakened" by the signals)

 */

 #ifndef _locking_h

 #define _locking_h

-

-#ifdef FAST_LOCK

-#include "fastlock.h"

-

-typedef fl_lock_t gen_lock_t;

-

-#define lock_alloc() shm_malloc(sizeof(gen_lock_t))

-#define lock_destroy(lock) /* do nothing */ 

-#define lock_dealloc(lock) shm_free(lock)

-

-inline static gen_lock_t* lock_init(gen_lock_t* lock)

-{

-	init_lock(*lock);

-	return lock;

-}

-

-#define lock_get(lock) get_lock(lock)

-#define lock_release(lock) release_lock(lock)

-

-

-

-#elif defined USE_PTHREAD_MUTEX

-#include <pthread.h>

-

-typedef pthread_mutex_t gen_lock_t;

-

-#define lock_alloc() shm_malloc(sizeof(gen_lock_t))

-#define lock_destroy(lock) /* do nothing */ 

-#define lock_dealloc(lock) shm_free(lock)

-

-inline static gen_lock_t* lock_init(gen_lock_t* lock)

-{

-	if (pthread_mutex_init(lock, 0)==0) return lock;

-	else return 0;

-}

-

-#define lock_get(lock) pthread_mutex_lock(lock)

-#define lock_release(lock) pthread_mutex_unlock(lock)

-

-

-

-#elif defined USE_POSIX_SEM

-#include <semaphore.h>

-

-typedef sem_t gen_lock_t;

-

-#define lock_alloc() shm_malloc(sizeof(gen_lock_t))

-#define lock_destroy(lock) /* do nothing */ 

-#define lock_dealloc(lock) shm_free(lock)

-

-inline static gen_lock_t* lock_init(gen_lock_t* lock)

-{

-	if (sem_init(lock, 1, 1)<0) return 0;

-	return lock;

-}

-

-#define lock_get(lock) sem_wait(lock)

-#define lock_release(lock) sem_post(lock)

-

-

-#elif defined USE_SYSV_SEM

-#include <sys/ipc.h>

-#include <sys/sem.h>

-

-#if ((defined(HAVE_UNION_SEMUN) || defined(__GNU_LIBRARY__) )&& !defined(_SEM_SEMUN_UNDEFINED)) 

-	

-	/* union semun is defined by including sem.h */

-#else

-	/* according to X/OPEN we have to define it ourselves */

-	union semun {

-		int val;                      /* value for SETVAL */

-		struct semid_ds *buf;         /* buffer for IPC_STAT, IPC_SET */

-		unsigned short int *array;    /* array for GETALL, SETALL */

-		struct seminfo *__buf;        /* buffer for IPC_INFO */

-	};

-#endif

-

-typedef int gen_lock_t;

-

-#define lock_alloc() shm_malloc(sizeof(gen_lock_t))

-#define lock_dealloc(lock) shm_free(lock)

-

-

-inline static gen_lock_t* lock_init(gen_lock_t* lock)

-{

-	union semun su;

-	

-	*lock=semget(IPC_PRIVATE, 1, 0700);

-	if (*lock==-1) return 0;

-	su.val=1;

-	if (semctl(*lock, 0, SETVAL, su)==-1){

-		/* init error*/

-		return 0;

-	}

-	return lock;

-}

-

-inline static void lock_destroy(gen_lock_t* lock)

-{

-	semctl(*lock, 0, IPC_RMID, (union semun)(int)0);

-}

-

-#define lock_dealloc(lock) shm_free(lock)

-

-inline static void lock_get(gen_lock_t* lock)

-{

-	struct sembuf sop;

-

-	sop.sem_num=0;

-	sop.sem_op=-1; /* down */

-	sop.sem_flg=0; /*SEM_UNDO*/

-	semop(*lock, &sop, 1);

-}

-

-inline static void lock_release(gen_lock_t* lock)

-{

-	struct sembuf sop;

-	

-	sop.sem_num=0;

-	sop.sem_op=1; /* up */

-	sop.sem_flg=0; /* SEM_UNDO*/

-	semop(*lock, &sop, 1);

-}

-

-#else

-#error "no locking method selected"

-#endif

-

-

-/*shm_{malloc, free}*/

-#include "mem/mem.h"

-#ifdef SHM_MEM

-#include "mem/shm_mem.h"

-#else

-#error "locking requires shared memroy support"

-#endif

+/* the order is important */

+#include "lock_ops.h"

+#include "lock_alloc.h" 

 #endif

@@ -28,17 +28,18 @@

 /*

  *   ser locking library

  *

- *  2002-12-16 created by andrei

- *

+ *  2002-12-16  created by andrei

+ *  2003-02-20  s/gen_lock_t/gen_lock_t/ to avoid a type conflict 

+ *               on solaris  (andrei)

  *

 Implements:

-	lock_t* lock_alloc();                    - allocates a lock in shared mem.

-	lock_t* lock_init(lock_t* lock);         - inits the lock

-	void    lock_destroy(lock_t* lock);      - removes the lock (e.g sysv rmid)

-	void    lock_dealloc(lock_t* lock);      - deallocates the lock's shared m.

-	void    lock_get(lock_t* lock);          - lock (mutex down)

-	void    lock_release(lock_t* lock);      - unlock (mutex up)

+	gen_lock_t* lock_alloc();               - allocates a lock in shared mem.

+	gen_lock_t* lock_init(gen_lock_t* lock);    - inits the lock

+	void    lock_destroy(gen_lock_t* lock); - removes the lock (e.g sysv rmid)

+	void    lock_dealloc(gen_lock_t* lock); - deallocates the lock's shared m.

+	void    lock_get(gen_lock_t* lock);     - lock (mutex down)

+	void    lock_release(gen_lock_t* lock); - unlock (mutex up)

 */

 #ifndef _locking_h

@@ -48,13 +49,13 @@ Implements:

 #ifdef FAST_LOCK

 #include "fastlock.h"

-typedef fl_lock_t lock_t;

+typedef fl_lock_t gen_lock_t;

-#define lock_alloc() shm_malloc(sizeof(lock_t))

+#define lock_alloc() shm_malloc(sizeof(gen_lock_t))

 #define lock_destroy(lock) /* do nothing */ 

 #define lock_dealloc(lock) shm_free(lock)

-inline static lock_t* lock_init(lock_t* lock)

+inline static gen_lock_t* lock_init(gen_lock_t* lock)

 {

 	init_lock(*lock);

 	return lock;

@@ -68,13 +69,13 @@ inline static lock_t* lock_init(lock_t* lock)

 #elif defined USE_PTHREAD_MUTEX

 #include <pthread.h>

-typedef pthread_mutex_t lock_t;

+typedef pthread_mutex_t gen_lock_t;

-#define lock_alloc() shm_malloc(sizeof(lock_t))

+#define lock_alloc() shm_malloc(sizeof(gen_lock_t))

 #define lock_destroy(lock) /* do nothing */ 

 #define lock_dealloc(lock) shm_free(lock)

-inline static lock_t* lock_init(lock_t* lock)

+inline static gen_lock_t* lock_init(gen_lock_t* lock)

 {

 	if (pthread_mutex_init(lock, 0)==0) return lock;

 	else return 0;

@@ -88,13 +89,13 @@ inline static lock_t* lock_init(lock_t* lock)

 #elif defined USE_POSIX_SEM

 #include <semaphore.h>

-typedef sem_t lock_t;

+typedef sem_t gen_lock_t;

-#define lock_alloc() shm_malloc(sizeof(lock_t))

+#define lock_alloc() shm_malloc(sizeof(gen_lock_t))

 #define lock_destroy(lock) /* do nothing */ 

 #define lock_dealloc(lock) shm_free(lock)

-inline static lock_t* lock_init(lock_t* lock)

+inline static gen_lock_t* lock_init(gen_lock_t* lock)

 {

 	if (sem_init(lock, 1, 1)<0) return 0;

 	return lock;

@@ -121,13 +122,13 @@ inline static lock_t* lock_init(lock_t* lock)

 	};

 #endif

-typedef int lock_t;

+typedef int gen_lock_t;

-#define lock_alloc() shm_malloc(sizeof(lock_t))

+#define lock_alloc() shm_malloc(sizeof(gen_lock_t))

 #define lock_dealloc(lock) shm_free(lock)

-inline static lock_t* lock_init(lock_t* lock)

+inline static gen_lock_t* lock_init(gen_lock_t* lock)

 {

 	union semun su;

@@ -141,14 +142,14 @@ inline static lock_t* lock_init(lock_t* lock)

 	return lock;

 }

-inline static void lock_destroy(lock_t* lock)

+inline static void lock_destroy(gen_lock_t* lock)

 {

 	semctl(*lock, 0, IPC_RMID, (union semun)(int)0);

 }

 #define lock_dealloc(lock) shm_free(lock)

-inline static void lock_get(lock_t* lock)

+inline static void lock_get(gen_lock_t* lock)

 {

 	struct sembuf sop;

@@ -158,7 +159,7 @@ inline static void lock_get(lock_t* lock)

 	semop(*lock, &sop, 1);

 }

-inline static void lock_release(lock_t* lock)

+inline static void lock_release(gen_lock_t* lock)

 {

 	struct sembuf sop;

@@ -44,12 +44,6 @@ Implements:

 #ifndef _locking_h

 #define _locking_h

-#include "mem/mem.h"

-#ifdef SHM_MEM

-#include "mem/shm_mem.h"

-#else

-#error "locking requires shared memroy support"

-#endif

 #ifdef FAST_LOCK

 #include "fastlock.h"

@@ -179,5 +173,12 @@ inline static void lock_release(lock_t* lock)

 #endif

+/*shm_{malloc, free}*/

+#include "mem/mem.h"

+#ifdef SHM_MEM

+#include "mem/shm_mem.h"

+#else

+#error "locking requires shared memroy support"

+#endif

 #endif

@@ -26,9 +26,11 @@

  */

 /*

-    ser locking library

-    - created 16.12.2003 (andrei)

-

+ *   ser locking library

+ *

+ *  2002-12-16 created by andrei

+ *

+ *

 Implements:

 	lock_t* lock_alloc();                    - allocates a lock in shared mem.

@@ -100,7 +102,7 @@ typedef sem_t lock_t;

 inline static lock_t* lock_init(lock_t* lock)

 {

-	if (sem_init(lock, 0, 1)<0) return 0;

+	if (sem_init(lock, 1, 1)<0) return 0;

 	return lock;

 }

@@ -105,7 +105,7 @@ inline static lock_t* lock_init(lock_t* lock)

 }

 #define lock_get(lock) sem_wait(lock)

-#define lock_release(lock) sem_release(lock)

+#define lock_release(lock) sem_post(lock)

 #elif defined USE_SYSV_SEM

@@ -127,21 +127,16 @@ inline static lock_t* lock_init(lock_t* lock)

 typedef int lock_t;

-inline static lock_t* lock_alloc()

-{

-	lock_t* l;

-	

-	l=shm_malloc(sizeof(lock_t));

-	if (l==0) return 0;

-	*l=semget(IPC_PRIVATE, 1, 0700);

-	if (*l==-1) return 0;

-	return l;

-}

+#define lock_alloc() shm_malloc(sizeof(lock_t))

+#define lock_dealloc(lock) shm_free(lock)

 inline static lock_t* lock_init(lock_t* lock)

 {

 	union semun su;

+	

+	*lock=semget(IPC_PRIVATE, 1, 0700);

+	if (*lock==-1) return 0;

 	su.val=1;

 	if (semctl(*lock, 0, SETVAL, su)==-1){

 		/* init error*/

@@ -157,7 +152,7 @@ inline static void lock_destroy(lock_t* lock)

 #define lock_dealloc(lock) shm_free(lock)

-inline void lock_get(lock_t* lock)

+inline static void lock_get(lock_t* lock)

 {

 	struct sembuf sop;

@@ -167,7 +162,7 @@ inline void lock_get(lock_t* lock)

 	semop(*lock, &sop, 1);

 }

-inline void lock_release(lock_t* lock)

+inline static void lock_release(lock_t* lock)

 {

 	struct sembuf sop;

new file mode 100644

@@ -0,0 +1,186 @@

+/* $Id$ */

+/*

+ *

+ * Copyright (C) 2001-2003 Fhg Fokus

+ *

+ * This file is part of ser, a free SIP server.

+ *

+ * ser 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 2 of the License, or

+ * (at your option) any later version

+ *

+ * For a license to use the ser software under conditions

+ * other than those described here, or to purchase support for this

+ * software, please contact iptel.org by e-mail at the following addresses:

+ *    info@iptel.org

+ *

+ * ser 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, write to the Free Software 

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

+ */

+

+/*

+    ser locking library

+    - created 16.12.2003 (andrei)

+

+Implements:

+

+	lock_t* lock_alloc();                    - allocates a lock in shared mem.

+	lock_t* lock_init(lock_t* lock);         - inits the lock

+	void    lock_destroy(lock_t* lock);      - removes the lock (e.g sysv rmid)

+	void    lock_dealloc(lock_t* lock);      - deallocates the lock's shared m.

+	void    lock_get(lock_t* lock);          - lock (mutex down)

+	void    lock_release(lock_t* lock);      - unlock (mutex up)

+*/

+

+#ifndef _locking_h

+#define _locking_h

+

+#include "mem/mem.h"

+#ifdef SHM_MEM

+#include "mem/shm_mem.h"

+#else

+#error "locking requires shared memroy support"

+#endif

+

+#ifdef FAST_LOCK

+#include "fastlock.h"

+

+typedef fl_lock_t lock_t;

+

+#define lock_alloc() shm_malloc(sizeof(lock_t))

+#define lock_destroy(lock) /* do nothing */ 

+#define lock_dealloc(lock) shm_free(lock)

+

+inline static lock_t* lock_init(lock_t* lock)

+{

+	init_lock(*lock);

+	return lock;

+}

+

+#define lock_get(lock) get_lock(lock)

+#define lock_release(lock) release_lock(lock)

+

+

+

+#elif defined USE_PTHREAD_MUTEX

+#include <pthread.h>

+

+typedef pthread_mutex_t lock_t;

+

+#define lock_alloc() shm_malloc(sizeof(lock_t))

+#define lock_destroy(lock) /* do nothing */ 

+#define lock_dealloc(lock) shm_free(lock)

+

+inline static lock_t* lock_init(lock_t* lock)

+{

+	if (pthread_mutex_init(lock, 0)==0) return lock;

+	else return 0;

+}

+

+#define lock_get(lock) pthread_mutex_lock(lock)

+#define lock_release(lock) pthread_mutex_unlock(lock)

+

+

+

+#elif defined USE_POSIX_SEM

+#include <semaphore.h>

+

+typedef sem_t lock_t;

+

+#define lock_alloc() shm_malloc(sizeof(lock_t))

+#define lock_destroy(lock) /* do nothing */ 

+#define lock_dealloc(lock) shm_free(lock)

+

+inline static lock_t* lock_init(lock_t* lock)

+{

+	if (sem_init(lock, 0, 1)<0) return 0;

+	return lock;

+}

+

+#define lock_get(lock) sem_wait(lock)

+#define lock_release(lock) sem_release(lock)

+

+

+#elif defined USE_SYSV_SEM

+#include <sys/ipc.h>

+#include <sys/sem.h>

+

+#if ((defined(HAVE_UNION_SEMUN) || defined(__GNU_LIBRARY__) )&& !defined(_SEM_SEMUN_UNDEFINED)) 

+	

+	/* union semun is defined by including sem.h */

+#else

+	/* according to X/OPEN we have to define it ourselves */

+	union semun {

+		int val;                      /* value for SETVAL */

+		struct semid_ds *buf;         /* buffer for IPC_STAT, IPC_SET */

+		unsigned short int *array;    /* array for GETALL, SETALL */

+		struct seminfo *__buf;        /* buffer for IPC_INFO */

+	};

+#endif

+

+typedef int lock_t;

+

+inline static lock_t* lock_alloc()

+{

+	lock_t* l;

+	

+	l=shm_malloc(sizeof(lock_t));

+	if (l==0) return 0;

+	*l=semget(IPC_PRIVATE, 1, 0700);

+	if (*l==-1) return 0;

+	return l;

+}

+

+

+inline static lock_t* lock_init(lock_t* lock)

+{

+	union semun su;

+	su.val=1;

+	if (semctl(*lock, 0, SETVAL, su)==-1){

+		/* init error*/

+		return 0;

+	}

+	return lock;

+}

+

+inline static void lock_destroy(lock_t* lock)

+{

+	semctl(*lock, 0, IPC_RMID, (union semun)(int)0);

+}

+

+#define lock_dealloc(lock) shm_free(lock)

+

+inline void lock_get(lock_t* lock)

+{

+	struct sembuf sop;

+