commit 342dfbeb8275f5ea6ed52dd3f30126614ec1d037

Author: Ingo Franzki <ifranzki@linux.ibm.com>

Date:   Mon Feb 15 14:33:07 2021 +0100

    Event support: pkcsslotd changes

    Signed-off-by: Ingo Franzki <ifranzki@linux.ibm.com>

diff --git a/configure.ac b/configure.ac

index e0ae4a82..a0b098e1 100644

--- a/configure.ac

+++ b/configure.ac

@@ -234,6 +234,12 @@ AC_ARG_WITH([systemd],

 	AS_HELP_STRING([--with-systemd@<:@=DIR@:>@],[systemd system unit files location]),

 	[],

 	[with_systemd=no])

+	

+dnl --- libudev development files

+AC_ARG_WITH([libudev],

+	AS_HELP_STRING([--with-libudev@<:@=DIR@:>@],[libudev development files location]),

+	[],

+	[with_libudev=check])

 dnl ---

 dnl ---

@@ -438,6 +444,46 @@ fi

 AC_SUBST([XCRYPTOLINZ_CFLAGS])

 AC_SUBST([XCRYPTOLINZ_LIBS])

+dnl --- with_libudev

+LIBUDEV_CFLAGS=

+LIBUDEV_LIBS=

+if test "x$with_libudev" != "xno"; then

+	if test "x$with_libudev" != "xyes" -a "x$with_libudev" != "xcheck"; then

+		LIBUDEV_CFLAGS="-I$with_libudev"

+		LIBUDEV_LIBS="-L$with_libudev"

+	fi

+	old_cflags="$CFLAGS"

+	old_libs="$LIBS"

+	CFLAGS="$CFLAGS $LIBUDEV_CFLAGS"

+	LIBS="$LIBS $LIBUDEV_LIBS"

+	# Use libudev only on s390 platforms, only s390 emits AP related uevents

+	case $target in

+	     *s390x* | *s390*)

+		CFLAGS="$CFLAGS -DWITH_LIBUDEV"

+		;;

+	     *)

+		if test "x$with_libudev" != "xyes"; then

+			with_libudev=no

+			echo "Default to 'with_libudev=no' on non-s390 platforms"

+		fi

+		;;

+	esac

+	if test "x$with_libudev" != "xno"; then

+		AC_CHECK_HEADER([libudev.h], [with_libudev=yes], [

+			AC_MSG_ERROR([Build with libudev requested but libudev headers couldn't be found])

+		])

+		AC_CHECK_LIB([udev], [udev_monitor_new_from_netlink], [with_libudev=yes], [

+			AC_MSG_ERROR([Build with libudev requested but libudev libraries couldn't be found])

+		])

+	fi

+	if test "x$with_libudev" = "xno"; then

+		CFLAGS="$old_cflags"

+		LIBS="$old_libs"

+	fi

+fi

+AC_SUBST([LIBUDEV_CFLAGS])

+AC_SUBST([LIBUDEV_LIBS])

+AM_CONDITIONAL([HAVE_LIBUDEV], [test "x$with_libudev" = "xyes"])

 dnl ---

 dnl --- Now check enabled features, while making sure every required

@@ -649,6 +695,7 @@ echo "	Daemon build:		$enable_daemon"

 echo "	Library build:		$enable_library"

 echo "	Systemd service:	$enable_systemd"

 echo "	Build with locks:	$enable_locks"

+echo "	Build with libudev:	$with_libudev"

 echo "	Build p11sak tool:	$enable_p11sak"

 echo "	token migrate tool:	$enable_pkcstok_migrate"

 echo

diff --git a/usr/include/slotmgr.h b/usr/include/slotmgr.h

index 4d038435..e37368a5 100644

--- a/usr/include/slotmgr.h

+++ b/usr/include/slotmgr.h

@@ -31,6 +31,7 @@

 #define OCK_API_LOCK_FILE LOCKDIR_PATH "/LCK..APIlock"

 #define PROC_SOCKET_FILE_PATH "/var/run/pkcsslotd.socket"

+#define ADMIN_SOCKET_FILE_PATH "/var/run/pkcsslotd.admin.socket"

 #define PID_FILE_PATH "/var/run/pkcsslotd.pid"

 #define OCK_CONFIG OCK_CONFDIR "/opencryptoki.conf"

@@ -45,6 +46,7 @@

 #define NUMBER_SLOTS_MANAGED 1024

 #define NUMBER_PROCESSES_ALLOWED  1000

+#define NUMBER_ADMINS_ALLOWED     1000

 //

 // Per Process Data structure

diff --git a/usr/sbin/pkcsslotd/pkcsslotd.h b/usr/sbin/pkcsslotd/pkcsslotd.h

index 69eb59f3..d7edcb3c 100644

--- a/usr/sbin/pkcsslotd/pkcsslotd.h

+++ b/usr/sbin/pkcsslotd/pkcsslotd.h

@@ -92,5 +92,8 @@ int init_socket_server();

 int term_socket_server();

 int init_socket_data(Slot_Mgr_Socket_t *sp);

 int socket_connection_handler(int timeout_secs);

+#ifdef DEV

+void dump_socket_handler();

+#endif

 #endif                          /* _SLOTMGR_H */

diff --git a/usr/sbin/pkcsslotd/pkcsslotd.mk b/usr/sbin/pkcsslotd/pkcsslotd.mk

index 2d36b4a9..c574edf8 100644

--- a/usr/sbin/pkcsslotd/pkcsslotd.mk

+++ b/usr/sbin/pkcsslotd/pkcsslotd.mk

@@ -8,6 +8,9 @@ CLEANFILES += usr/lib/common/parser.c usr/lib/common/parser.h	\

 	usr/lib/common/parser.output usr/lib/common/lexer.c

 usr_sbin_pkcsslotd_pkcsslotd_LDFLAGS = -lpthread -lcrypto

+if HAVE_LIBUDEV

+usr_sbin_pkcsslotd_pkcsslotd_LDFLAGS += -ludev

+endif

 usr_sbin_pkcsslotd_pkcsslotd_CFLAGS = -DPROGRAM_NAME=\"$(@)\"	\

 	-I${srcdir}/usr/include -I${srcdir}/usr/lib/common	\

diff --git a/usr/sbin/pkcsslotd/signal.c b/usr/sbin/pkcsslotd/signal.c

index 49482a2f..17167632 100644

--- a/usr/sbin/pkcsslotd/signal.c

+++ b/usr/sbin/pkcsslotd/signal.c

@@ -21,7 +21,7 @@

 extern BOOL IsValidProcessEntry(pid_t_64 pid, time_t_64 RegTime);

 static int SigsToIntercept[] = {

-    SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGALRM,

+    SIGHUP, SIGINT, SIGQUIT, SIGALRM,

     SIGTERM, SIGTSTP, SIGTTIN,

     SIGTTOU, SIGUSR1, SIGUSR2, SIGPROF

 };

@@ -32,8 +32,11 @@ static int SigsToIntercept[] = {

 /* SIGCHLD - Don't want to exit.  Should never receive, but we do, apparently

  * when something tries to cancel the GC Thread */

+/* SIGPIPE - Don't want to exit.  May happen when a connection to an admin

+ * event sender or a process is closed before all events are delivered. */

+

 static int SigsToIgnore[] = {

-    SIGCHLD,

+    SIGCHLD, SIGPIPE,

 };

@@ -71,6 +74,10 @@ void slotdGenericSignalHandler(int Signal)

     CheckForGarbage(shmp);

 #endif

+#ifdef DEV

+    dump_socket_handler();

+#endif

+

     for (procindex = 0; (procindex < NUMBER_PROCESSES_ALLOWED); procindex++) {

         Slot_Mgr_Proc_t_64 *pProc = &(shmp->proc_table[procindex]);

diff --git a/usr/sbin/pkcsslotd/socket_server.c b/usr/sbin/pkcsslotd/socket_server.c

index 1fae0b95..41408670 100644

--- a/usr/sbin/pkcsslotd/socket_server.c

+++ b/usr/sbin/pkcsslotd/socket_server.c

@@ -1,4 +1,6 @@

 /*

+ * COPYRIGHT (c) International Business Machines Corp. 2013, 2021

+ *

  * This program is provided under the terms of the Common Public License,

  * version 1.0 (CPL-1.0). Any use, reproduction or distribution for this

  * software constitutes recipient's acceptance of CPL-1.0 terms which can be

@@ -12,6 +14,8 @@

 #include <stdio.h>

 #include <unistd.h>

 #include <string.h>

+#include <stdlib.h>

+#include <fcntl.h>

 #include <sys/time.h>

 #include <sys/socket.h>

@@ -19,32 +23,1225 @@

 #include <sys/select.h>

 #include <sys/stat.h>

 #include <grp.h>

+#include <sys/epoll.h>

+

+#if defined(__GNUC__) && __GNUC__ >= 7 || defined(__clang__) && __clang_major__ >= 12

+    #define FALL_THROUGH __attribute__ ((fallthrough))

+#else

+    #define FALL_THROUGH ((void)0)

+#endif

+

+#ifdef WITH_LIBUDEV

+#include <libudev.h>

+#endif

 #include "log.h"

 #include "slotmgr.h"

 #include "pkcsslotd.h"

 #include "apictl.h"

+#include "dlist.h"

+#include "events.h"

+

+#define MAX_EPOLL_EVENTS            128

+

+#ifdef WITH_LIBUDEV

+#define UDEV_RECV_BUFFFER_SIZE      512 * 1024

+#define UDEV_SUBSYSTEM_AP           "ap"

+#define UDEV_ACTION_BIND            "bind"

+#define UDEV_ACTION_UNBIND          "unbind"

+#define UDEV_ACTION_DEVTYPE_APQN    "ap_queue"

+#define UDEV_PROERTY_DEVTYPE        "DEV_TYPE"

+#endif

+

+struct epoll_info {

+    int (* notify)(int events, void *private);

+    void (* free)(void *private);

+    void *private;

+    unsigned long ref_count;

+};

+

+struct listener_info {

+    int socket;

+    const char *file_path;

+    int (* new_conn)(int socket, struct listener_info *listener);

+    struct epoll_info ep_info;

+    unsigned long num_clients;

+    unsigned long max_num_clients;

+};

+

+enum xfer_state {

+    XFER_IDLE = 0,

+    XFER_RECEIVE = 1,

+    XFER_SEND = 2,

+};

+

+struct client_info {

+    int socket;

+    int (* xfer_complete)(void *client);

+    void (* hangup)(void *client);

+    void (* free)(void *client);

+    void *client;

+    struct epoll_info ep_info;

+    enum xfer_state xfer_state;

+    char *xfer_buffer;

+    size_t xfer_size;

+    size_t xfer_offset;

+};

+

+enum proc_state {

+    PROC_INITIAL_SEND = 0,

+    PROC_WAIT_FOR_EVENT = 1,

+    PROC_SEND_EVENT = 2,

+    PROC_SEND_PAYLOAD = 3,

+    PROC_RECEIVE_REPLY = 4,

+    PROC_HANGUP = 5,

+};

+

+struct proc_conn_info {

+    struct client_info client_info;

+    enum proc_state state;

+    DL_NODE *events;

+    struct event_info *event;

+    event_reply_t reply;

+};

+

+enum admin_state {

+    ADMIN_RECEIVE_EVENT = 0,

+    ADMIN_RECEIVE_PAYLOAD = 1,

+    ADMIN_EVENT_DELIVERED = 2,

+    ADMIN_SEND_REPLY = 3,

+    ADMIN_WAIT_FOR_EVENT_LIMIT = 4,

+    ADMIN_HANGUP = 5,

+};

+

+struct admin_conn_info {

+    struct client_info client_info;

+    enum admin_state state;

+    struct event_info *event;

+};

+

+#ifdef WITH_LIBUDEV

+struct udev_mon {

+    struct udev *udev;

+    struct udev_monitor *mon;

+    int socket;

+    struct epoll_info ep_info;

+    struct event_info *delayed_event;

+};

+#endif

+

+struct event_info {

+    event_msg_t event;

+    char *payload;

+    event_reply_t reply;

+    unsigned long proc_ref_count;      /* # of processes using this event */

+    struct admin_conn_info *admin_ref; /* Admin connection to send reply back */

+};

+

+static int epoll_fd = -1;

+static struct listener_info proc_listener;

+static DL_NODE *proc_connections = NULL;

+static struct listener_info admin_listener;

+static DL_NODE *admin_connections = NULL;

+#ifdef WITH_LIBUDEV

+static struct udev_mon udev_mon;

+#endif

+static DL_NODE *pending_events = NULL;

+static unsigned long pending_events_count = 0;

+

+#define MAX_PENDING_EVENTS      1024

+

+/*

+ * Iterate over all connections in a safe way. Before actually iterating,

+ * increment the ref count of ALL connections, because any processing may

+ * cause any of the connections to be hang-up, and thus freed and removed

+ * from the list. We need to make sure that while we are iterating over the

+ * connections, none of them gets removed from the list.

+ */

+#define FOR_EACH_CONN_SAFE_BEGIN(list, conn) {                              \

+        DL_NODE *_node, *_next;                                             \

+        _node = dlist_get_first(list);                                      \

+        while (_node != NULL) {                                             \

+            conn = _node->data;                                             \

+            _next = dlist_next(_node);                                      \

+            client_socket_get(&(conn)->client_info);                        \

+            _node = _next;                                                  \

+        }                                                                   \

+        _node = dlist_get_first(list);                                      \

+        while (_node != NULL) {                                             \

+            conn = _node->data;                                             \

+            _next = dlist_next(_node);

+

+#define FOR_EACH_CONN_SAFE_END(list, conn)                                  \

+            _node = _next;                                                  \

+        }                                                                   \

+        _node = dlist_get_first(list);                                      \

+        while (_node != NULL) {                                             \

+            conn = _node->data;                                             \

+            _next = dlist_next(_node);                                      \

+            client_socket_put(&(conn)->client_info);                        \

+            _node = _next;                                                  \

+        }                                                                   \

+    }

+

+

+

+static void listener_socket_close(int socketfd, const char *file_path);

+static int listener_client_hangup(struct listener_info *listener);

+static void event_delivered(struct event_info *event);

+static int client_socket_notify(int events, void *private);

+static void client_socket_free(void *private);

+static int proc_xfer_complete(void *client);

+static int proc_start_deliver_event(struct proc_conn_info *conn);

+static int proc_deliver_event(struct proc_conn_info *conn,

+                              struct event_info *event);

+static int proc_event_delivered(struct proc_conn_info *conn,

+                                struct event_info *event);

+static inline void proc_get(struct proc_conn_info *conn);

+static inline void proc_put(struct proc_conn_info *conn);

+static void proc_hangup(void *client);

+static void proc_free(void *client);

+static int admin_xfer_complete(void *client);

+static void admin_event_limit_underrun(struct admin_conn_info *conn);

+static int admin_event_delivered(struct admin_conn_info *conn,

+                                 struct event_info *event);

+static inline void admin_get(struct admin_conn_info *conn);

+static inline void admin_put(struct admin_conn_info *conn);

+static void admin_hangup(void *client);

+static void admin_free(void *client);

+#ifdef WITH_LIBUDEV

+static void udev_mon_term(struct udev_mon *udev_mon);

+static int udev_mon_notify(int events, void *private);

+#endif

+

+static void epoll_info_init(struct epoll_info *epoll_info,

+                    int (* notify)(int events, void *private),

+                    void (* free_cb)(void *private),

+                    void *private)

+{

+    epoll_info->ref_count = 1;

+    epoll_info->notify = notify;

+    epoll_info->free = free_cb;

+    epoll_info->private = private;

+}

+

+static void epoll_info_get(struct epoll_info *epoll_info)

+{

+    epoll_info->ref_count++;

+

+    DbgLog(DL3, "%s: private: %p, ref_count: %lu", __func__,

+           epoll_info->private, epoll_info->ref_count);

+}

+

+static void epoll_info_put(struct epoll_info *epoll_info)

+{

+    if (epoll_info->ref_count > 0)

+        epoll_info->ref_count--;

+

+    DbgLog(DL3, "%s: private: %p, ref_count: %lu", __func__,

+           epoll_info->private, epoll_info->ref_count);

+

+    if (epoll_info->ref_count == 0 && epoll_info->free != NULL)

+        epoll_info->free(epoll_info->private);

+}

+

+static int client_socket_init(int socket, int (* xfer_complete)(void *client),

+                              void (* hangup)(void *client),

+                              void (* free_cb)(void *client), void *client,

+                              struct client_info *client_info)

+{

+    struct epoll_event evt;

+    int rc, err;

+

+    if (xfer_complete == NULL || hangup == NULL)

+        return -EINVAL;

+

+    epoll_info_init(&client_info->ep_info, client_socket_notify,

+                    client_socket_free, client_info);

+    client_info->socket = socket;

+    client_info->xfer_complete = xfer_complete;

+    client_info->hangup = hangup;

+    client_info->free = free_cb;

+    client_info->client = client;

+    client_info->xfer_state = XFER_IDLE;

+

+    rc = fcntl(socket, F_SETFL, O_NONBLOCK);

+    if (rc < 0) {

+        err = errno;

+        InfoLog("%s: Failed to set client socket %d to non-blocking, errno "

+                "%d (%s).", __func__, socket, err, strerror(err));

+        return -err;

+    }

+

+    evt.events = EPOLLIN | EPOLLOUT | EPOLLRDHUP | EPOLLERR | EPOLLET;

+    evt.data.ptr = &client_info->ep_info;

+    rc = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, socket, &evt);

+    if (rc != 0) {

+        err = errno;

+        InfoLog("%s: Failed to add client socket %d to epoll, errno %d (%s).",

+                 __func__, socket, err, strerror(err));

+        close(socket);

+        return -err;

+    }

+

+    return 0;

+}

+

+static inline void client_socket_get(struct client_info *client_info)

+{

+    epoll_info_get(&client_info->ep_info);

+}

+

+static inline void client_socket_put(struct client_info *client_info)

+{

+    epoll_info_put(&client_info->ep_info);

+}

+

+static void client_socket_term(struct client_info *client_info)

+{

+    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_info->socket, NULL);

+    close(client_info->socket);

+    client_info->socket = -1;

+}

+

+static int client_socket_notify(int events, void *private)

+{

+    struct client_info *client_info = private;

+    ssize_t num;

+    int rc, err, socket = client_info->socket;

+

+    DbgLog(DL3, "%s: Epoll event on client %p socket %d: events: 0x%x xfer: %d",

+           __func__, client_info, socket, events, client_info->xfer_state);

+

+    if (socket < 0)

+        return -ENOTCONN;

+

+    if (events & (EPOLLHUP | EPOLLERR)) {

+        DbgLog(DL3, "EPOLLHUP | EPOLLERR");

+

+        client_info->hangup(client_info->client);

+        client_info = NULL; /* client_info may have been freed by now */

+        return 0;

+    }

+

+    if (client_info->xfer_state == XFER_RECEIVE && (events & EPOLLIN)) {

+        DbgLog(DL3, "%s: EPOLLIN: buffer: %p size: %lu ofs: %lu", __func__,

+               client_info->xfer_buffer, client_info->xfer_size,

+               client_info->xfer_offset);

+

+        num = read(client_info->socket,

+                   client_info->xfer_buffer + client_info->xfer_offset,

+                   client_info->xfer_size - client_info->xfer_offset);

+        if (num <= 0) {

+            err = errno;

+

+            DbgLog(DL3, "%s: read failed with: num: %d errno: %d (%s)",

+                   __func__, num, num < 0 ? err : 0,

+                   num < 0 ? strerror(err) : "none");

+

+            if (num < 0 && err == EWOULDBLOCK)

+                return 0; /* Will be continued when socket becomes readable */

+

+            /* assume connection closed by peer */

+            client_info->hangup(client_info->client);

+            client_info = NULL; /* client_info may have been freed by now */

+            return 0;

+        } else {

+            DbgLog(DL3, "%s: %lu bytes received", __func__, num);

+

+            client_info->xfer_offset += num;

+

+            DbgLog(DL3, "%s: %lu bytes left", __func__,

+                   client_info->xfer_size - client_info->xfer_offset);

+

+            if (client_info->xfer_offset >= client_info->xfer_size) {

+                client_info->xfer_state = XFER_IDLE;

+                client_info->xfer_buffer = NULL;

+                client_info->xfer_size = 0;

+                client_info->xfer_offset = 0;

+

+                client_socket_get(client_info);

+                rc = client_info->xfer_complete(client_info->client);

+                if (rc != 0) {

+                    InfoLog("%s: xfer_complete callback failed for client "

+                            "socket %d, rc: %d", __func__, socket,

+                            rc);

+                    client_info->hangup(client_info->client);

+                }

+                client_socket_put(client_info);

+                client_info = NULL; /* client_info may have been freed by now */

+                return rc;

+            }

+            return 0;

+        }

+    }

+

+    if (client_info->xfer_state == XFER_SEND && (events & EPOLLOUT)) {

+        DbgLog(DL3, "%s: EPOLLOUT: buffer: %p size: %lu ofs: %lu", __func__,

+               client_info->xfer_buffer, client_info->xfer_size,

+               client_info->xfer_offset);

+

+        num = write(client_info->socket,

+                    client_info->xfer_buffer + client_info->xfer_offset,

+                    client_info->xfer_size - client_info->xfer_offset);

+        if (num < 0) {

+            err = errno;

+

+            DbgLog(DL3, "%s: write failed with: errno: %d (%s)", __func__, err,

+                   strerror(err));

+

+            if (err == EWOULDBLOCK)

+                return 0; /* Will be continued when socket becomes writable */

+

+            /* assume connection closed by peer */

+            client_info->hangup(client_info->client);

+            client_info = NULL; /* client_info may have been freed by now */

+            return 0;

+        } else {

+            DbgLog(DL3, "%s: %lu bytes sent", __func__, num);

+

+            client_info->xfer_offset += num;

+

+            DbgLog(DL3, "%s: %lu bytes left", __func__,

+                   client_info->xfer_size - client_info->xfer_offset);

+

+            if (client_info->xfer_offset >= client_info->xfer_size) {

+                client_info->xfer_state = XFER_IDLE;

+                client_info->xfer_buffer = NULL;

+                client_info->xfer_size = 0;

+                client_info->xfer_offset = 0;

+

+                client_socket_get(client_info);

+                rc = client_info->xfer_complete(client_info->client);

+                if (rc != 0) {

+                    InfoLog("%s: xfer_complete callback failed for client "

+                            "socket %d, rc: %d", __func__, socket,

+                            rc);

+                    client_info->hangup(client_info->client);

+                }

+                client_socket_put(client_info);

+                client_info = NULL; /* client_info may have been freed by now */

+                return rc;

+            }

+            return 0;

+        }

+    }

+

+    return 0;

+}

+

+static void client_socket_free(void *private)

+{

+    struct client_info *client_info = private;

+

+    DbgLog(DL3, "%s: %p", __func__, client_info);

+

+    if (client_info->free != NULL)

+        client_info->free(client_info->client);

+}

+

+static int client_socket_receive(struct client_info *client_info,

+                                 void *buffer, size_t size)

+{

+    if (client_info->socket < 0)

+        return -ENOTCONN;

+

+    client_info->xfer_state = XFER_RECEIVE;

+    client_info->xfer_buffer = (char *)buffer;

+    client_info->xfer_size = size;

+    client_info->xfer_offset = 0;

+

+    DbgLog(DL3, "%s: Start receive on client socket %d: buffer: %p size: %lu",

+            __func__, client_info->socket, buffer, size);

+

+    return client_socket_notify(EPOLLIN, client_info);

+}

+

+

+static int client_socket_send(struct client_info *client_info,

+                              void *buffer, size_t size)

+{

+    if (client_info->socket < 0)

+        return -ENOTCONN;

+

+    client_info->xfer_state = XFER_SEND;

+    client_info->xfer_buffer = (char *)buffer;

+    client_info->xfer_size = size;

+    client_info->xfer_offset = 0;

+

+    DbgLog(DL3, "%s: Start send on client socket %d: buffer: %p size: %lu",

+            __func__, client_info->socket, buffer, size);

+

+    return client_socket_notify(EPOLLOUT, client_info);

+}

+

+static struct event_info *event_new(unsigned int payload_len,

+                                    struct admin_conn_info *admin_conn)

+{

+    struct event_info *event;

+

+    event = calloc(1, sizeof(struct event_info));

+    if (event == NULL) {

+        ErrLog("%s: Failed to allocate the event", __func__);

+        return NULL;

+    }

+

+    event->event.version = EVENT_VERSION_1;

+    event->event.payload_len = payload_len;

+    if (payload_len > 0) {

+        event->payload = malloc(payload_len);

+        if (event->payload == NULL) {

+            ErrLog("%s: Failed to allocate the event payload", __func__);

+            free(event);

+            return NULL;

+        }

+    }

+

+    event->reply.version = EVENT_VERSION_1;

+

+    if (admin_conn != NULL)

+        admin_get(admin_conn);

+    event->admin_ref = admin_conn;

+

+    DbgLog(DL3, "%s: allocated event: %p", __func__, event);

+    return event;

+}

+

+static void event_limit_underrun()

+{

+    struct admin_conn_info *conn;

+

+    DbgLog(DL3, "%s: pending_events_count: %lu", __func__, pending_events_count);

+

+#ifdef WITH_LIBUDEV

+    /* Notify the udev monitor */

+    udev_mon_notify(EPOLLIN, &udev_mon);

+#endif

+

+    /* Notify all admin connections */

+    FOR_EACH_CONN_SAFE_BEGIN(admin_connections, conn) {

+        admin_event_limit_underrun(conn);

+    }

+    FOR_EACH_CONN_SAFE_END(admin_connections, conn)

+}

+

+static void event_free(struct event_info *event)

+{

+    DbgLog(DL3, "%s: free event: %p", __func__, event);

+

+    if (event->payload != NULL)

+        free(event->payload);

+    free(event);

+}

+

+static int event_add_to_pending_list(struct event_info *event)

+{

+    DL_NODE *list;

+

+    list = dlist_add_as_last(pending_events, event);

+    if (list == NULL) {

+        ErrLog("%s: failed add event to list of pending events", __func__);

+        return -ENOMEM;

+    }

+    pending_events = list;

+

+    pending_events_count++;

+

+    return 0;

+}

+

+static void event_remove_from_pending_list(struct event_info *event)

+{

+    DL_NODE *node;

+    int trigger = 0;