开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
pass_persist.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：22k
源码类别：

SNMP编程

开发平台：

Unix_Linux

pass_persist.c：源码内容
  1. #include <net-snmp/net-snmp-config.h>
  3. #if HAVE_IO_H
  4. #include <io.h>
  5. #endif
  6. #if HAVE_STDLIB_H
  7. #include <stdlib.h>
  8. #endif
  9. #if HAVE_STRING_H
  10. #include <string.h>
  11. #else
  12. #include <strings.h>
  13. #endif
  14. #if HAVE_UNISTD_H
  15. #include <unistd.h>
  16. #endif
  17. #include <ctype.h>
  18. #include <sys/types.h>
  19. #if HAVE_NETINET_IN_H
  20. #include <netinet/in.h>
  21. #endif
  22. #if HAVE_SYS_WAIT_H
  23. # include <sys/wait.h>
  24. #endif
  25. #if HAVE_WINSOCK_H
  26. #include <winsock.h>
  27. #endif
  29. #if HAVE_DMALLOC_H
  30. #include <dmalloc.h>
  31. #endif
  33. #include <signal.h>
  34. #include <errno.h>
  36. #include <net-snmp/net-snmp-includes.h>
  37. #include <net-snmp/agent/net-snmp-agent-includes.h>
  39. #include "struct.h"
  40. #include "pass_persist.h"
  41. #include "extensible.h"
  42. #include "util_funcs.h"
  44. struct extensible *persistpassthrus = NULL;
  45. int             numpersistpassthrus = 0;
  46. struct persist_pipe_type {
  47.     FILE           *fIn, *fOut;
  48.     int             fdIn, fdOut;
  49.     int             pid;
  50. }              *persist_pipes = (struct persist_pipe_type *) NULL;
  51. static int      init_persist_pipes(void);
  52. static void     close_persist_pipe(int iindex);
  53. static int      open_persist_pipe(int iindex, char *command);
  54. static void     destruct_persist_pipes(void);
  55. static int      write_persist_pipe(int iindex, const char *data);
  57. /*
  58.  * These are defined in pass.c 
  59.  */
  60. extern int      asc2bin(char *p);
  61. extern int      bin2asc(char *p, size_t n);
  62. extern int      snmp_oid_min_compare(const oid *, size_t, const oid *,
  63.                                      size_t);
  65. /*
  66.  * the relocatable extensible commands variables 
  67.  */
  68. struct variable2 extensible_persist_passthru_variables[] = {
  69.     /*
  70.      * bogus entry.  Only some of it is actually used. 
  71.      */
  72.     {MIBINDEX, ASN_INTEGER, RWRITE, var_extensible_pass_persist, 0,
  73.      {MIBINDEX}},
  74. };
  76. void
  77. init_pass_persist(void)
  78. {
  79.     snmpd_register_config_handler("pass_persist",
  80.                                   pass_persist_parse_config,
  81.                                   pass_persist_free_config,
  82.                                   "miboid program");
  83. }
  85. void
  86. pass_persist_parse_config(const char *token, char *cptr)
  87. {
  88.     struct extensible **ppass = &persistpassthrus, **etmp, *ptmp;
  89.     char           *tcptr;
  90.     int             i;
  92.     if (*cptr == '.')
  93.         cptr++;
  94.     if (!isdigit(*cptr)) {
  95.         config_perror("second token is not a OID");
  96.         return;
  97.     }
  98.     numpersistpassthrus++;
  100.     while (*ppass != NULL)
  101.         ppass = &((*ppass)->next);
  102.     (*ppass) = (struct extensible *) malloc(sizeof(struct extensible));
  103.     if (*ppass == NULL)
  104.         return;
  105.     (*ppass)->type = PASSTHRU_PERSIST;
  107.     (*ppass)->miblen = parse_miboid(cptr, (*ppass)->miboid);
  108.     while (isdigit(*cptr) || *cptr == '.')
  109.         cptr++;
  110.     /*
  111.      * name 
  112.      */
  113.     cptr = skip_white(cptr);
  114.     if (cptr == NULL) {
  115.         config_perror("No command specified on pass_persist line");
  116.         (*ppass)->command[0] = 0;
  117.     } else {
  118.         for (tcptr = cptr; *tcptr != 0 && *tcptr != '#' && *tcptr != ';';
  119.              tcptr++);
  120.         strncpy((*ppass)->command, cptr, tcptr - cptr);
  121.         (*ppass)->command[tcptr - cptr] = 0;
  122.     }
  123.     strncpy((*ppass)->name, (*ppass)->command, sizeof((*ppass)->name));
  124.     (*ppass)->name[ sizeof((*ppass)->name)-1 ] = 0;
  125.     (*ppass)->next = NULL;
  127.     register_mib("pass_persist",
  128.                  (struct variable *) extensible_persist_passthru_variables,
  129.                  sizeof(struct variable2), 1, (*ppass)->miboid,
  130.                  (*ppass)->miblen);
  132.     /*
  133.      * argggg -- pasthrus must be sorted 
  134.      */
  135.     if (numpersistpassthrus > 1) {
  136.         etmp = (struct extensible **)
  137.             malloc(((sizeof(struct extensible *)) * numpersistpassthrus));
  138.         if (etmp == NULL)
  139.             return;
  140.         for (i = 0, ptmp = (struct extensible *) persistpassthrus;
  141.              i < numpersistpassthrus && ptmp != 0; i++, ptmp = ptmp->next)
  142.             etmp[i] = ptmp;
  143.         qsort(etmp, numpersistpassthrus, sizeof(struct extensible *),
  144.               pass_persist_compare);
  145.         persistpassthrus = (struct extensible *) etmp[0];
  146.         ptmp = (struct extensible *) etmp[0];
  148.         for (i = 0; i < numpersistpassthrus - 1; i++) {
  149.             ptmp->next = etmp[i + 1];
  150.             ptmp = ptmp->next;
  151.         }
  152.         ptmp->next = NULL;
  153.         free(etmp);
  154.     }
  155. }
  157. void
  158. pass_persist_free_config(void)
  159. {
  160.     struct extensible *etmp, *etmp2;
  162.     /*
  163.      * Close any open pipes to any programs 
  164.      */
  165.     destruct_persist_pipes();
  167.     for (etmp = persistpassthrus; etmp != NULL;) {
  168.         etmp2 = etmp;
  169.         etmp = etmp->next;
  170.         unregister_mib(etmp2->miboid, etmp2->miblen);
  171.         free(etmp2);
  172.     }
  173.     persistpassthrus = NULL;
  174.     numpersistpassthrus = 0;
  175. }
  177. u_char         *
  178. var_extensible_pass_persist(struct variable *vp,
  179.                             oid * name,
  180.                             size_t * length,
  181.                             int exact,
  182.                             size_t * var_len, WriteMethod ** write_method)
  183. {
  184.     oid             newname[MAX_OID_LEN];
  185.     int             i, rtest, newlen;
  186.     static long     long_ret;
  187.     char            buf[SNMP_MAXBUF];
  188.     static char     buf2[SNMP_MAXBUF];
  189.     static oid      objid[MAX_OID_LEN];
  190.     struct extensible *persistpassthru;
  191.     FILE           *file;
  193.     /*
  194.      * Make sure that our basic pipe structure is malloced 
  195.      */
  196.     init_persist_pipes();
  198.     long_ret = *length;
  199.     for (i = 1; i <= numpersistpassthrus; i++) {
  200.         persistpassthru = get_exten_instance(persistpassthrus, i);
  201.         rtest = snmp_oid_min_compare(name, *length,
  202.                                      persistpassthru->miboid,
  203.                                      persistpassthru->miblen);
  204.         if ((exact && rtest == 0) || (!exact && rtest <= 0)) {
  205.             /*
  206.              * setup args 
  207.              */
  208.             if (persistpassthru->miblen >= *length || rtest < 0)
  209.                 sprint_mib_oid(buf, persistpassthru->miboid,
  210.                                persistpassthru->miblen);
  211.             else
  212.                 sprint_mib_oid(buf, name, *length);
  214.             /*
  215.              * Open our pipe if necessary 
  216.              */
  217.             if (!open_persist_pipe(i, persistpassthru->name)) {
  218.                 return (NULL);
  219.             }
  221.             if (exact)
  222.                 snprintf(persistpassthru->command,
  223.                   sizeof(persistpassthru->command), "getn%sn", buf);
  224.             else
  225.                 snprintf(persistpassthru->command,
  226.                   sizeof(persistpassthru->command), "getnextn%sn", buf);
  227.             persistpassthru->command[ sizeof(persistpassthru->command)-1 ] = 0;
  229.             DEBUGMSGTL(("ucd-snmp/pass_persist",
  230.                         "persistpass-sending:n%s",
  231.                         persistpassthru->command));
  232.             if (!write_persist_pipe(i, persistpassthru->command)) {
  233.                 *var_len = 0;
  234.                 /*
  235.                  * close_persist_pipes is called in write_persist_pipe 
  236.                  */
  237.                 return (NULL);
  238.             }
  240.             /*
  241.              * valid call.  Exec and get output 
  242.              */
  243.             if ((file = persist_pipes[i].fIn)) {
  244.                 if (fgets(buf, sizeof(buf), file) == NULL) {
  245.                     *var_len = 0;
  246.                     close_persist_pipe(i);
  247.                     return (NULL);
  248.                 }
  249.                 /*
  250.                  * persistant scripts return "NONEn" on invalid items 
  251.                  */
  252.                 if (!strncmp(buf, "NONE", 4)) {
  253.                     if (exact) {
  254.                         *var_len = 0;
  255.                         return (NULL);
  256.                     }
  257.                     continue;
  258.                 }
  259.                 newlen = parse_miboid(buf, newname);
  261.                 /*
  262.                  * its good, so copy onto name/length 
  263.                  */
  264.                 memcpy((char *) name, (char *) newname,
  265.                        (int) newlen * sizeof(oid));
  266.                 *length = newlen;
  268.                 /*
  269.                  * set up return pointer for setable stuff 
  270.                  */
  271.                 *write_method = setPassPersist;
  273.                 if (newlen == 0 || fgets(buf, sizeof(buf), file) == NULL
  274.                     || fgets(buf2, sizeof(buf2), file) == NULL) {
  275.                     *var_len = 0;
  276.                     close_persist_pipe(i);
  277.                     return (NULL);
  278.                 }
  280.                 /*
  281.                  * buf contains the return type, and buf2 contains the data 
  282.                  */
  283.                 if (!strncasecmp(buf, "string", 6)) {
  284.                     buf2[strlen(buf2) - 1] = 0; /* zap the linefeed */
  285.                     *var_len = strlen(buf2);
  286.                     vp->type = ASN_OCTET_STR;
  287.                     return ((unsigned char *) buf2);
  288.                 } else if (!strncasecmp(buf, "integer", 7)) {
  289.                     *var_len = sizeof(long_ret);
  290.                     long_ret = strtol(buf2, NULL, 10);
  291.                     vp->type = ASN_INTEGER;
  292.                     return ((unsigned char *) &long_ret);
  293.                 } else if (!strncasecmp(buf, "unsigned", 8)) {
  294.                     *var_len = sizeof(long_ret);
  295.                     long_ret = strtoul(buf2, NULL, 10);
  296.                     vp->type = ASN_UNSIGNED;
  297.                     return ((unsigned char *) &long_ret);
  298.                 } else if (!strncasecmp(buf, "counter", 7)) {
  299.                     *var_len = sizeof(long_ret);
  300.                     long_ret = strtoul(buf2, NULL, 10);
  301.                     vp->type = ASN_COUNTER;
  302.                     return ((unsigned char *) &long_ret);
  303.                 } else if (!strncasecmp(buf, "octet", 5)) {
  304.                     *var_len = asc2bin(buf2);
  305.                     vp->type = ASN_OCTET_STR;
  306.                     return ((unsigned char *) buf2);
  307.                 } else if (!strncasecmp(buf, "opaque", 6)) {
  308.                     *var_len = asc2bin(buf2);
  309.                     vp->type = ASN_OPAQUE;
  310.                     return ((unsigned char *) buf2);
  311.                 } else if (!strncasecmp(buf, "gauge", 5)) {
  312.                     *var_len = sizeof(long_ret);
  313.                     long_ret = strtoul(buf2, NULL, 10);
  314.                     vp->type = ASN_GAUGE;
  315.                     return ((unsigned char *) &long_ret);
  316.                 } else if (!strncasecmp(buf, "objectid", 8)) {
  317.                     newlen = parse_miboid(buf2, objid);
  318.                     *var_len = newlen * sizeof(oid);
  319.                     vp->type = ASN_OBJECT_ID;
  320.                     return ((unsigned char *) objid);
  321.                 } else if (!strncasecmp(buf, "timetick", 8)) {
  322.                     *var_len = sizeof(long_ret);
  323.                     long_ret = strtoul(buf2, NULL, 10);
  324.                     vp->type = ASN_TIMETICKS;
  325.                     return ((unsigned char *) &long_ret);
  326.                 } else if (!strncasecmp(buf, "ipaddress", 9)) {
  327.                     newlen = parse_miboid(buf2, objid);
  328.                     if (newlen != 4) {
  329.                         snmp_log(LOG_ERR,
  330.                                  "invalid ipaddress returned:  %sn",
  331.                                  buf2);
  332.                         *var_len = 0;
  333.                         return (NULL);
  334.                     }
  335.                     long_ret =
  336.                         (objid[0] << (8 * 3)) + (objid[1] << (8 * 2)) +
  337.                         (objid[2] << 8) + objid[3];
  338.                     long_ret = htonl(long_ret);
  339.                     *var_len = sizeof(long_ret);
  340.                     vp->type = ASN_IPADDRESS;
  341.                     return ((unsigned char *) &long_ret);
  342.                 }
  343.             }
  344.             *var_len = 0;
  345.             return (NULL);
  346.         }
  347.     }
  348.     if (var_len)
  349.         *var_len = 0;
  350.     *write_method = NULL;
  351.     return (NULL);
  352. }
  354. int
  355. setPassPersist(int action,
  356.                u_char * var_val,
  357.                u_char var_val_type,
  358.                size_t var_val_len,
  359.                u_char * statP, oid * name, size_t name_len)
  360. {
  361.     int             i, rtest;
  362.     struct extensible *persistpassthru;
  364.     char            buf[SNMP_MAXBUF], buf2[SNMP_MAXBUF];
  365.     long            tmp;
  366.     unsigned long   utmp;
  368.     /*
  369.      * Make sure that our basic pipe structure is malloced 
  370.      */
  371.     init_persist_pipes();
  373.     for (i = 1; i <= numpersistpassthrus; i++) {
  374.         persistpassthru = get_exten_instance(persistpassthrus, i);
  375.         rtest = snmp_oid_min_compare(name, name_len,
  376.                                      persistpassthru->miboid,
  377.                                      persistpassthru->miblen);
  378.         if (rtest <= 0) {
  379.             if (action != ACTION)
  380.                 return SNMP_ERR_NOERROR;
  381.             /*
  382.              * setup args 
  383.              */
  384.             if (persistpassthru->miblen >= name_len || rtest < 0)
  385.                 sprint_mib_oid(buf, persistpassthru->miboid,
  386.                                persistpassthru->miblen);
  387.             else
  388.                 sprint_mib_oid(buf, name, name_len);
  389.             snprintf(persistpassthru->command,
  390.                      sizeof(persistpassthru->command), "setn%sn", buf);
  391.             persistpassthru->command[ sizeof(persistpassthru->command)-1 ] = 0;
  392.             switch (var_val_type) {
  393.             case ASN_INTEGER:
  394.             case ASN_COUNTER:
  395.             case ASN_GAUGE:
  396.             case ASN_TIMETICKS:
  397.                 tmp = *((long *) var_val);
  398.                 switch (var_val_type) {
  399.                 case ASN_INTEGER:
  400.                     sprintf(buf, "integer %dn", (int) tmp);
  401.                     break;
  402.                 case ASN_COUNTER:
  403.                     sprintf(buf, "counter %dn", (int) tmp);
  404.                     break;
  405.                 case ASN_GAUGE:
  406.                     sprintf(buf, "gauge %dn", (int) tmp);
  407.                     break;
  408.                 case ASN_TIMETICKS:
  409.                     sprintf(buf, "timeticks %dn", (int) tmp);
  410.                     break;
  411.                 }
  412.                 break;
  413.             case ASN_IPADDRESS:
  414.                 utmp = *((u_long *) var_val);
  415.                 utmp = ntohl(utmp);
  416.                 sprintf(buf, "ipaddress %d.%d.%d.%dn",
  417.                         (int) ((utmp & 0xff000000) >> (8 * 3)),
  418.                         (int) ((utmp & 0xff0000) >> (8 * 2)),
  419.                         (int) ((utmp & 0xff00) >> (8)),
  420.                         (int) ((utmp & 0xff)));
  421.                 break;
  422.             case ASN_OCTET_STR:
  423.                 memcpy(buf2, var_val, var_val_len);
  424.                 if (var_val_len == 0)
  425.                     sprintf(buf, "string ""n");
  426.                 else if (bin2asc(buf2, var_val_len) == (int) var_val_len)
  427.                     snprintf(buf, sizeof(buf), "string "%s"n", buf2);
  428.                 else
  429.                     snprintf(buf, sizeof(buf), "octet "%s"n", buf2);
  430.                 buf[ sizeof(buf)-1 ] = 0;
  431.                 break;
  432.             case ASN_OBJECT_ID:
  433.                 sprint_mib_oid(buf2, (oid *) var_val, var_val_len);
  434.                 snprintf(buf, sizeof(buf), "objectid "%s"n", buf2);
  435.                 buf[ sizeof(buf)-1 ] = 0;
  436.                 break;
  437.             }
  438.             strncat(persistpassthru->command, buf,
  439.                     sizeof(persistpassthru->command) -
  440.                     strlen(persistpassthru->command) - 2);
  441.             persistpassthru->command[ sizeof(persistpassthru->command)-2 ] = 'n';
  442.             persistpassthru->command[ sizeof(persistpassthru->command)-1 ] = 0;
  444.             if (!open_persist_pipe(i, persistpassthru->name)) {
  445.                 return SNMP_ERR_NOTWRITABLE;
  446.             }
  448.             DEBUGMSGTL(("ucd-snmp/pass_persist",
  449.                         "persistpass-writing:  %sn",
  450.                         persistpassthru->command));
  451.             if (!write_persist_pipe(i, persistpassthru->command)) {
  452.                 close_persist_pipe(i);
  453.                 return SNMP_ERR_NOTWRITABLE;
  454.             }
  456.             if (fgets(buf, sizeof(buf), persist_pipes[i].fIn) == NULL) {
  457.                 close_persist_pipe(i);
  458.                 return SNMP_ERR_NOTWRITABLE;
  459.             }
  461.             if (!strncasecmp(buf, "not-writable", 12)) {
  462.                 return SNMP_ERR_NOTWRITABLE;
  463.             } else if (!strncasecmp(buf, "wrong-type", 10)) {
  464.                 return SNMP_ERR_WRONGTYPE;
  465.             }
  466.             return SNMP_ERR_NOERROR;
  467.         }
  468.     }
  469.     if (snmp_get_do_debugging()) {
  470.         sprint_mib_oid(buf2, name, name_len);
  471.         DEBUGMSGTL(("ucd-snmp/pass_persist", "persistpass-notfound:  %sn",
  472.                     buf2));
  473.     }
  474.     return SNMP_ERR_NOSUCHNAME;
  475. }
  477. int
  478. pass_persist_compare(const void *a, const void *b)
  479. {
  480.     const struct extensible *const *ap, *const *bp;
  481.     ap = (const struct extensible * const *) a;
  482.     bp = (const struct extensible * const *) b;
  483.     return snmp_oid_compare((*ap)->miboid, (*ap)->miblen, (*bp)->miboid,
  484.                             (*bp)->miblen);
  485. }
  487. /*
  488.  * Initialize our persistant pipes
  489.  *   - Returns 1 on success, 0 on failure.
  490.  *   - Initializes all FILE pointers to NULL to indicate "closed"
  491.  */
  492. static int
  493. init_persist_pipes(void)
  494. {
  495.     int             i;
  497.     /*
  498.      * if we are already taken care of, just return 
  499.      */
  500.     if (persist_pipes) {
  501.         return persist_pipes ? 1 : 0;
  502.     }
  504.     /*
  505.      * Otherwise malloc and initialize 
  506.      */
  507.     persist_pipes = (struct persist_pipe_type *)
  508.         malloc(sizeof(struct persist_pipe_type) *
  509.                (numpersistpassthrus + 1));
  510.     if (persist_pipes) {
  511.         for (i = 0; i <= numpersistpassthrus; i++) {
  512.             persist_pipes[i].fIn = persist_pipes[i].fOut = (FILE *) 0;
  513.             persist_pipes[i].fdIn = persist_pipes[i].fdOut = -1;
  514.             persist_pipes[i].pid = -1;
  515.         }
  516.     }
  517.     return persist_pipes ? 1 : 0;
  518. }
  520. /*
  521.  * Destruct our persistant pipes
  522.  *
  523.  */
  524. static void
  525. destruct_persist_pipes(void)
  526. {
  527.     int             i;
  529.     /*
  530.      * Return if there are no pipes 
  531.      */
  532.     if (!persist_pipes) {
  533.         return;
  534.     }
  536.     for (i = 0; i <= numpersistpassthrus; i++) {
  537.         close_persist_pipe(i);
  538.     }
  540.     free(persist_pipes);
  541.     persist_pipes = (struct persist_pipe_type *) 0;
  542. }
  544. /*
  545.  * returns 0 on failure, 1 on success 
  546.  */
  547. static int
  548. open_persist_pipe(int iindex, char *command)
  549. {
  550.     static int      recurse = 0;        /* used to allow one level of recursion */
  552.     DEBUGMSGTL(("ucd-snmp/pass_persist", "open_persist_pipe(%d,'%s')n",
  553.                 iindex, command));
  554.     /*
  555.      * Open if it's not already open 
  556.      */
  557.     if (persist_pipes[iindex].pid == -1) {
  558.         int             fdIn, fdOut, pid;
  560.         /*
  561.          * Did we fail? 
  562.          */
  563.         if ((0 == get_exec_pipes(command, &fdIn, &fdOut, &pid)) ||
  564.             (pid == -1)) {
  565.             DEBUGMSGTL(("ucd-snmp/pass_persist",
  566.                         "open_persist_pipe: pid == -1n"));
  567.             recurse = 0;
  568.             return 0;
  569.         }
  571.         /*
  572.          * If not, fill out our structure 
  573.          */
  574.         persist_pipes[iindex].pid = pid;
  575.         persist_pipes[iindex].fdIn = fdIn;
  576.         persist_pipes[iindex].fdOut = fdOut;
  577.         persist_pipes[iindex].fIn = fdopen(fdIn, "r");
  578.         persist_pipes[iindex].fOut = fdopen(fdOut, "w");
  580.         /*
  581.          * Setup our -non-buffered-io- 
  582.          */
  583.         setbuf(persist_pipes[iindex].fOut, (char *) 0);
  584.     }
  586.     /*
  587.      * Send test packet always so we can self-catch 
  588.      */
  589.     {
  590.         char            buf[SNMP_MAXBUF];
  591.         /*
  592.          * Should catch SIGPIPE around this call! 
  593.          */
  594.         if (!write_persist_pipe(iindex, "PINGn")) {
  595.             DEBUGMSGTL(("ucd-snmp/pass_persist",
  596.                         "open_persist_pipe: Error writing PINGn"));
  597.             close_persist_pipe(iindex);
  599.             /*
  600.              * Recurse one time if we get a SIGPIPE 
  601.              */
  602.             if (!recurse) {
  603.                 recurse = 1;
  604.                 return open_persist_pipe(iindex, command);
  605.             }
  606.             recurse = 0;
  607.             return 0;
  608.         }
  609.         if (fgets(buf, sizeof(buf), persist_pipes[iindex].fIn) == NULL) {
  610.             DEBUGMSGTL(("ucd-snmp/pass_persist",
  611.                         "open_persist_pipe: Error reading for PONGn"));
  612.             close_persist_pipe(iindex);
  613.             recurse = 0;
  614.             return 0;
  615.         }
  616.         if (strncmp(buf, "PONG", 4)) {
  617.             DEBUGMSGTL(("ucd-snmp/pass_persist",
  618.                         "open_persist_pipe: PONG not received!n"));
  619.             close_persist_pipe(iindex);
  620.             recurse = 0;
  621.             return 0;
  622.         }
  623.     }
  625.     recurse = 0;
  626.     return 1;
  627. }
  629. #if STRUCT_SIGACTION_HAS_SA_SIGACTION
  630. /*
  631.  * Generic handler 
  632.  */
  633. void
  634. sigpipe_handler(int sig, siginfo_t * sip, void *uap)
  635. {
  636.     return;
  637. }
  638. #endif
  640. static int
  641. write_persist_pipe(int iindex, const char *data)
  642. {
  643. #if HAVE_SIGNAL
  644.     struct sigaction sa, osa;
  645.     int             wret = 0, werrno = 0;
  647.     /*
  648.      * Don't write to a non-existant process 
  649.      */
  650.     if (persist_pipes[iindex].pid == -1) {
  651.         return 0;
  652.     }
  654.     /*
  655.      * Setup our signal action to catch SIGPIPEs 
  656.      */
  657.     sa.sa_handler = NULL;
  658. #if STRUCT_SIGACTION_HAS_SA_SIGACTION
  659.     sa.sa_sigaction = &sigpipe_handler;
  660. #endif
  661.     sigemptyset(&sa.sa_mask);
  662.     sa.sa_flags = 0;
  663.     if (sigaction(SIGPIPE, &sa, &osa)) {
  664.         DEBUGMSGTL(("ucd-snmp/pass_persist",
  665.                     "write_persist_pipe: sigaction failed: %d", errno));
  666.     }
  668.     /*
  669.      * Do the write 
  670.      */
  671.     wret = write(persist_pipes[iindex].fdOut, data, strlen(data));
  672.     werrno = errno;
  674.     /*
  675.      * Reset the signal handler 
  676.      */
  677.     sigaction(SIGPIPE, &osa, (struct sigaction *) 0);
  679.     if (wret < 0) {
  680.         if (werrno != EINTR) {
  681.             DEBUGMSGTL(("ucd-snmp/pass_persist",
  682.                         "write_persist_pipe: write returned unknown error %dn",
  683.                         errno));
  684.         }
  685.         close_persist_pipe(iindex);
  686.         return 0;
  687.     }
  688. #endif                          /* HAVE_SIGNAL */
  689.     return 1;
  690. }
  692. static void
  693. close_persist_pipe(int iindex)
  694. {
  696.     /*
  697.      * Check and nix every item 
  698.      */
  699.     if (persist_pipes[iindex].fOut) {
  700.         fclose(persist_pipes[iindex].fOut);
  701.         persist_pipes[iindex].fOut = (FILE *) 0;
  702.     }
  703.     if (persist_pipes[iindex].fdOut != -1) {
  704.         close(persist_pipes[iindex].fdOut);
  705.         persist_pipes[iindex].fdOut = -1;
  706.     }
  707.     if (persist_pipes[iindex].fIn) {
  708.         fclose(persist_pipes[iindex].fIn);
  709.         persist_pipes[iindex].fIn = (FILE *) 0;
  710.     }
  711.     if (persist_pipes[iindex].fdIn != -1) {
  712.         close(persist_pipes[iindex].fdIn);
  713.         persist_pipes[iindex].fdIn = -1;
  714.     }
  715.     if (persist_pipes[iindex].pid != -1) {
  716. #if HAVE_SYS_WAIT_H
  717.         waitpid(persist_pipes[iindex].pid, 0, 0);
  718. #endif
  719.         persist_pipes[iindex].pid = -1;
  720.     }
  722. }