Logo
Home page Net-SNMP

Archive Search:

Require all words?

Site Search:
Google
Main Page | Modules | Data Structures | File List | Data Fields | Related Pages | Examples

fd_event_manager.c

00001 /* UNIT: File Descriptor (FD) Event Manager                              */
00002 #include <net-snmp/net-snmp-config.h>
00003 #ifdef HAVE_SYS_SELECT
00004 #include <sys/select.h>
00005 #endif
00006 #include <net-snmp/net-snmp-includes.h>
00007 #include <net-snmp/library/snmp_api.h>
00008 #include <net-snmp/library/fd_event_manager.h>
00009 #include <net-snmp/library/snmp_logging.h>
00010 int     external_readfd[NUM_EXTERNAL_FDS],   external_readfdlen   = 0;
00011 int     external_writefd[NUM_EXTERNAL_FDS],  external_writefdlen  = 0;
00012 int     external_exceptfd[NUM_EXTERNAL_FDS], external_exceptfdlen = 0;
00013 void  (*external_readfdfunc[NUM_EXTERNAL_FDS]) (int, void *);
00014 void  (*external_writefdfunc[NUM_EXTERNAL_FDS]) (int, void *);
00015 void  (*external_exceptfdfunc[NUM_EXTERNAL_FDS]) (int, void *);
00016 void   *external_readfd_data[NUM_EXTERNAL_FDS];
00017 void   *external_writefd_data[NUM_EXTERNAL_FDS];
00018 void   *external_exceptfd_data[NUM_EXTERNAL_FDS];
00019 
00020 /*
00021  * Register a given fd for read events.  Call callback when events
00022  * are received.
00023  */
00024 int
00025 register_readfd(int fd, void (*func) (int, void *), void *data)
00026 {
00027     if (external_readfdlen < NUM_EXTERNAL_FDS) {
00028         external_readfd[external_readfdlen] = fd;
00029         external_readfdfunc[external_readfdlen] = func;
00030         external_readfd_data[external_readfdlen] = data;
00031         external_readfdlen++;
00032         DEBUGMSGTL(("fd_event_manager:register_readfd", "registered fd %d\n", fd));
00033         return FD_REGISTERED_OK;
00034     } else {
00035         snmp_log(LOG_CRIT, "register_readfd: too many file descriptors\n");
00036         return FD_REGISTRATION_FAILED;
00037     }
00038 }
00039 
00040 /*
00041  * Register a given fd for write events.  Call callback when events
00042  * are received.
00043  */
00044 int
00045 register_writefd(int fd, void (*func) (int, void *), void *data)
00046 {
00047     if (external_writefdlen < NUM_EXTERNAL_FDS) {
00048         external_writefd[external_writefdlen] = fd;
00049         external_writefdfunc[external_writefdlen] = func;
00050         external_writefd_data[external_writefdlen] = data;
00051         external_writefdlen++;
00052         DEBUGMSGTL(("fd_event_manager:register_writefd", "registered fd %d\n", fd));
00053         return FD_REGISTERED_OK;
00054     } else {
00055         snmp_log(LOG_CRIT,
00056                  "register_writefd: too many file descriptors\n");
00057         return FD_REGISTRATION_FAILED;
00058     }
00059 }
00060 
00061 /*
00062  * Register a given fd for exception events.  Call callback when events
00063  * are received.
00064  */
00065 int
00066 register_exceptfd(int fd, void (*func) (int, void *), void *data)
00067 {
00068     if (external_exceptfdlen < NUM_EXTERNAL_FDS) {
00069         external_exceptfd[external_exceptfdlen] = fd;
00070         external_exceptfdfunc[external_exceptfdlen] = func;
00071         external_exceptfd_data[external_exceptfdlen] = data;
00072         external_exceptfdlen++;
00073         DEBUGMSGTL(("fd_event_manager:register_exceptfd", "registered fd %d\n", fd));
00074         return FD_REGISTERED_OK;
00075     } else {
00076         snmp_log(LOG_CRIT,
00077                  "register_exceptfd: too many file descriptors\n");
00078         return FD_REGISTRATION_FAILED;
00079     }
00080 }
00081 
00082 /*
00083  * Unregister a given fd for read events.
00084  */ 
00085 int
00086 unregister_readfd(int fd)
00087 {
00088     int             i, j;
00089 
00090     for (i = 0; i < external_readfdlen; i++) {
00091         if (external_readfd[i] == fd) {
00092             external_readfdlen--;
00093             for (j = i; j < external_readfdlen; j++) {
00094                 external_readfd[j] = external_readfd[j + 1];
00095                 external_readfdfunc[j] = external_readfdfunc[j + 1];
00096                 external_readfd_data[j] = external_readfd_data[j + 1];
00097             }
00098             DEBUGMSGTL(("fd_event_manager:unregister_readfd", "unregistered fd %d\n", fd));
00099             return FD_UNREGISTERED_OK;
00100         }
00101     }
00102     return FD_NO_SUCH_REGISTRATION;
00103 }
00104 
00105 /*
00106  * Unregister a given fd for read events.
00107  */ 
00108 int
00109 unregister_writefd(int fd)
00110 {
00111     int             i, j;
00112 
00113     for (i = 0; i < external_writefdlen; i++) {
00114         if (external_writefd[i] == fd) {
00115             external_writefdlen--;
00116             for (j = i; j < external_writefdlen; j++) {
00117                 external_writefd[j] = external_writefd[j + 1];
00118                 external_writefdfunc[j] = external_writefdfunc[j + 1];
00119                 external_writefd_data[j] = external_writefd_data[j + 1];
00120             }
00121             DEBUGMSGTL(("fd_event_manager:unregister_writefd", "unregistered fd %d\n", fd));
00122             return FD_UNREGISTERED_OK;
00123         }
00124     }
00125     return FD_NO_SUCH_REGISTRATION;
00126 }
00127 
00128 /*
00129  * Unregister a given fd for exception events.
00130  */
00131 int
00132 unregister_exceptfd(int fd)
00133 {
00134     int             i, j;
00135 
00136     for (i = 0; i < external_exceptfdlen; i++) {
00137         if (external_exceptfd[i] == fd) {
00138             external_exceptfdlen--;
00139             for (j = i; j < external_exceptfdlen; j++) {
00140                 external_exceptfd[j] = external_exceptfd[j + 1];
00141                 external_exceptfdfunc[j] = external_exceptfdfunc[j + 1];
00142                 external_exceptfd_data[j] = external_exceptfd_data[j + 1];
00143             }
00144             DEBUGMSGTL(("fd_event_manager:unregister_exceptfd", "unregistered fd %d\n",
00145                         fd));
00146             return FD_UNREGISTERED_OK;
00147         }
00148     }
00149     return FD_NO_SUCH_REGISTRATION;
00150 }
00151 
00152 /* 
00153  * NET-SNMP External Event Info 
00154  */
00155 void netsnmp_external_event_info(int *numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds)
00156 {
00157   int i;
00158   for (i = 0; i < external_readfdlen; i++) {
00159     FD_SET(external_readfd[i], readfds);
00160     if (external_readfd[i] >= *numfds)
00161       *numfds = external_readfd[i] + 1;
00162   }
00163   for (i = 0; i < external_writefdlen; i++) {
00164     FD_SET(external_writefd[i], writefds);
00165     if (external_writefd[i] >= *numfds)
00166       *numfds = external_writefd[i] + 1;
00167   }
00168   for (i = 0; i < external_exceptfdlen; i++) {
00169     FD_SET(external_exceptfd[i], exceptfds);
00170     if (external_exceptfd[i] >= *numfds)
00171       *numfds = external_exceptfd[i] + 1;
00172   }
00173 }
00174 
00175 /* 
00176  * NET-SNMP Dispatch External Events 
00177  */
00178 void netsnmp_dispatch_external_events(int *count, fd_set *readfds, fd_set *writefds, fd_set *exceptfds)
00179 {
00180   int i;
00181   for (i = 0; *count && (i < external_readfdlen); i++) {
00182       if (FD_ISSET(external_readfd[i], readfds)) {
00183           DEBUGMSGTL(("fd_event_manager:netsnmp_dispatch_external_events", 
00184                      "readfd[%d] = %d\n", i, external_readfd[i]));
00185           external_readfdfunc[i] (external_readfd[i],
00186                                   external_readfd_data[i]);
00187           FD_CLR(external_readfd[i], readfds);
00188           *count--;
00189       }
00190   }
00191   for (i = 0; *count && (i < external_writefdlen); i++) {
00192       if (FD_ISSET(external_writefd[i], writefds)) {
00193           DEBUGMSGTL(("fd_event_manager:netsnmp_dispatch_external_events", 
00194                      "writefd[%d] = %d\n", i, external_writefd[i]));
00195           external_writefdfunc[i] (external_writefd[i],
00196                                    external_writefd_data[i]);
00197           FD_CLR(external_writefd[i], writefds);
00198           *count--;
00199       }
00200   }
00201   for (i = 0; *count && (i < external_exceptfdlen); i++) {
00202       if (FD_ISSET(external_exceptfd[i], exceptfds)) {
00203           DEBUGMSGTL(("fd_event_manager:netsnmp_dispatch_external_events", 
00204                      "exceptfd[%d] = %d\n", i, external_exceptfd[i]));
00205           external_exceptfdfunc[i] (external_exceptfd[i],
00206                                     external_exceptfd_data[i]);
00207           FD_CLR(external_exceptfd[i], exceptfds);
00208           *count--;
00209       }
00210   }
00211 }

Generated on Fri Dec 30 13:47:44 2005 for net-snmp by  doxygen 1.3.9.1

Valid CSS!


Last modified: Thursday, 01-Mar-2007 16:20:07 PST
For questions regarding web content and site functionality, please write to the net-snmp-users mail list.