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

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

SNMP编程

开发平台：

Unix_Linux

proc.c：源码内容
  1. #include <net-snmp/net-snmp-config.h>
  3. #ifdef solaris2
  4. #define _KMEMUSER               /* Needed by <sys/user.h> */
  5. #include <sys/types.h>          /* helps define struct rlimit */
  6. #endif
  8. #if HAVE_IO_H                   /* win32 */
  9. #include <io.h>
  10. #endif
  11. #if HAVE_STDLIB_H
  12. #include <stdlib.h>
  13. #endif
  14. #if HAVE_UNISTD_H
  15. #include <unistd.h>
  16. #endif
  17. #if HAVE_STRING_H
  18. #include <string.h>
  19. #else
  20. #include <strings.h>
  21. #endif
  22. #if HAVE_MALLOC_H
  23. #include <malloc.h>
  24. #endif
  25. #include <math.h>
  26. #include <ctype.h>
  27. #include <sys/types.h>
  28. #if HAVE_NETINET_IN_H
  29. #include <netinet/in.h>
  30. #endif
  31. #if TIME_WITH_SYS_TIME
  32. # ifdef WIN32
  33. #  include <sys/timeb.h>
  34. # else
  35. #  include <sys/time.h>
  36. # endif
  37. # include <time.h>
  38. #else
  39. # if HAVE_SYS_TIME_H
  40. #  include <sys/time.h>
  41. # else
  42. #  include <time.h>
  43. # endif
  44. #endif
  45. #if HAVE_KVM_H
  46. #include <kvm.h>
  47. #endif
  48. #if HAVE_WINSOCK_H
  49. #include <winsock.h>
  50. #endif
  52. #if HAVE_DMALLOC_H
  53. #include <dmalloc.h>
  54. #endif
  56. #include <net-snmp/net-snmp-includes.h>
  57. #include <net-snmp/agent/net-snmp-agent-includes.h>
  59. #include "struct.h"
  60. #include "proc.h"
  61. #ifdef USING_UCD_SNMP_ERRORMIB_MODULE
  62. #include "errormib.h"
  63. #else
  64. #define setPerrorstatus(x) snmp_log_perror(x)
  65. #endif
  66. #include "util_funcs.h"
  67. #include "kernel.h"
  69. static struct myproc *get_proc_instance(struct myproc *, oid);
  70. struct myproc  *procwatch = NULL;
  71. static struct extensible fixproc;
  72. int             numprocs = 0;
  74. void
  75. init_proc(void)
  76. {
  78.     /*
  79.      * define the structure we're going to ask the agent to register our
  80.      * information at 
  81.      */
  82.     struct variable2 extensible_proc_variables[] = {
  83.         {MIBINDEX, ASN_INTEGER, RONLY, var_extensible_proc, 1, {MIBINDEX}},
  84.         {ERRORNAME, ASN_OCTET_STR, RONLY, var_extensible_proc, 1,
  85.          {ERRORNAME}},
  86.         {PROCMIN, ASN_INTEGER, RONLY, var_extensible_proc, 1, {PROCMIN}},
  87.         {PROCMAX, ASN_INTEGER, RONLY, var_extensible_proc, 1, {PROCMAX}},
  88.         {PROCCOUNT, ASN_INTEGER, RONLY, var_extensible_proc, 1,
  89.          {PROCCOUNT}},
  90.         {ERRORFLAG, ASN_INTEGER, RONLY, var_extensible_proc, 1,
  91.          {ERRORFLAG}},
  92.         {ERRORMSG, ASN_OCTET_STR, RONLY, var_extensible_proc, 1,
  93.          {ERRORMSG}},
  94.         {ERRORFIX, ASN_INTEGER, RWRITE, var_extensible_proc, 1,
  95.          {ERRORFIX}},
  96.         {ERRORFIXCMD, ASN_OCTET_STR, RONLY, var_extensible_proc, 1,
  97.          {ERRORFIXCMD}}
  98.     };
  100.     /*
  101.      * Define the OID pointer to the top of the mib tree that we're
  102.      * registering underneath 
  103.      */
  104.     oid             proc_variables_oid[] = { UCDAVIS_MIB, PROCMIBNUM, 1 };
  106.     /*
  107.      * register ourselves with the agent to handle our mib tree 
  108.      */
  109.     REGISTER_MIB("ucd-snmp/proc", extensible_proc_variables, variable2,
  110.                  proc_variables_oid);
  112.     snmpd_register_config_handler("proc", proc_parse_config,
  113.                                   proc_free_config,
  114.                                   "process-name [max-num] [min-num]");
  115.     snmpd_register_config_handler("procfix", procfix_parse_config, NULL,
  116.                                   "process-name program [arguments...]");
  117. }
  120. /*
  121.  * Define snmpd.conf reading routines first.  They get called
  122.  * automatically by the invocation of a macro in the proc.h file. 
  123.  */
  125. void
  126. proc_free_config(void)
  127. {
  128.     struct myproc  *ptmp, *ptmp2;
  130.     for (ptmp = procwatch; ptmp != NULL;) {
  131.         ptmp2 = ptmp;
  132.         ptmp = ptmp->next;
  133.         free(ptmp2);
  134.     }
  135.     procwatch = NULL;
  136.     numprocs = 0;
  137. }
  139. /*
  140.  * find a give entry in the linked list associated with a proc name 
  141.  */
  142. static struct myproc *
  143. get_proc_by_name(char *name)
  144. {
  145.     struct myproc  *ptmp;
  147.     if (name == NULL)
  148.         return NULL;
  150.     for (ptmp = procwatch; ptmp != NULL && strcmp(ptmp->name, name) != 0;
  151.          ptmp = ptmp->next);
  152.     return ptmp;
  153. }
  155. void
  156. procfix_parse_config(const char *token, char *cptr)
  157. {
  158.     char            tmpname[STRMAX];
  159.     struct myproc  *procp;
  161.     /*
  162.      * don't allow two entries with the same name 
  163.      */
  164.     cptr = copy_nword(cptr, tmpname, sizeof(tmpname));
  165.     if ((procp = get_proc_by_name(tmpname)) == NULL) {
  166.         config_perror("No proc entry registered for this proc name yet.");
  167.         return;
  168.     }
  170.     if (strlen(cptr) > sizeof(procp->fixcmd)) {
  171.         config_perror("fix command too long.");
  172.         return;
  173.     }
  175.     strcpy(procp->fixcmd, cptr);
  176. }
  179. void
  180. proc_parse_config(const char *token, char *cptr)
  181. {
  182.     char            tmpname[STRMAX];
  183.     struct myproc **procp = &procwatch;
  185.     /*
  186.      * don't allow two entries with the same name 
  187.      */
  188.     copy_nword(cptr, tmpname, sizeof(tmpname));
  189.     if (get_proc_by_name(tmpname) != NULL) {
  190.         config_perror("Already have an entry for this process.");
  191.         return;
  192.     }
  194.     /*
  195.      * skip past used ones 
  196.      */
  197.     while (*procp != NULL)
  198.         procp = &((*procp)->next);
  200.     (*procp) = (struct myproc *) calloc(1, sizeof(struct myproc));
  201.     if (*procp == NULL)
  202.         return;                 /* memory alloc error */
  203.     numprocs++;
  204.     /*
  205.      * not blank and not a comment 
  206.      */
  207.     copy_nword(cptr, (*procp)->name, sizeof((*procp)->name));
  208.     cptr = skip_not_white(cptr);
  209.     if ((cptr = skip_white(cptr))) {
  210.         (*procp)->max = atoi(cptr);
  211.         cptr = skip_not_white(cptr);
  212.         if ((cptr = skip_white(cptr)))
  213.             (*procp)->min = atoi(cptr);
  214.         else
  215.             (*procp)->min = 0;
  216.     } else {
  217.         (*procp)->max = 0;
  218.         (*procp)->min = 0;
  219.     }
  220. #ifdef PROCFIXCMD
  221.     sprintf((*procp)->fixcmd, PROCFIXCMD, (*procp)->name);
  222. #endif
  223.     DEBUGMSGTL(("ucd-snmp/proc", "Read:  %s (%d) (%d)n",
  224.                 (*procp)->name, (*procp)->max, (*procp)->min));
  225. }
  227. /*
  228.  * The routine that handles everything 
  229.  */
  231. u_char         *
  232. var_extensible_proc(struct variable *vp,
  233.                     oid * name,
  234.                     size_t * length,
  235.                     int exact,
  236.                     size_t * var_len, WriteMethod ** write_method)
  237. {
  239.     struct myproc  *proc;
  240.     static long     long_ret;
  241.     static char     errmsg[300];
  244.     if (header_simple_table
  245.         (vp, name, length, exact, var_len, write_method, numprocs))
  246.         return (NULL);
  248.     if ((proc = get_proc_instance(procwatch, name[*length - 1]))) {
  249.         switch (vp->magic) {
  250.         case MIBINDEX:
  251.             long_ret = name[*length - 1];
  252.             return ((u_char *) (&long_ret));
  253.         case ERRORNAME:        /* process name to check for */
  254.             *var_len = strlen(proc->name);
  255.             return ((u_char *) (proc->name));
  256.         case PROCMIN:
  257.             long_ret = proc->min;
  258.             return ((u_char *) (&long_ret));
  259.         case PROCMAX:
  260.             long_ret = proc->max;
  261.             return ((u_char *) (&long_ret));
  262.         case PROCCOUNT:
  263.             long_ret = sh_count_procs(proc->name);
  264.             return ((u_char *) (&long_ret));
  265.         case ERRORFLAG:
  266.             long_ret = sh_count_procs(proc->name);
  267.             if (long_ret >= 0 &&
  268.                 ((proc->min && long_ret < proc->min) ||
  269.                  (proc->max && long_ret > proc->max) ||
  270.                  (proc->min == 0 && proc->max == 0 && long_ret < 1))) {
  271.                 long_ret = 1;
  272.             } else {
  273.                 long_ret = 0;
  274.             }
  275.             return ((u_char *) (&long_ret));
  276.         case ERRORMSG:
  277.             long_ret = sh_count_procs(proc->name);
  278.             if (long_ret < 0) {
  279.                 errmsg[0] = 0;  /* catch out of mem errors return 0 count */
  280.             } else if (proc->min && long_ret < proc->min) {
  281.                 snprintf(errmsg, sizeof(errmsg),
  282.                         "Too few %s running (# = %d)",
  283.                         proc->name, (int) long_ret);
  284.             } else if (proc->max && long_ret > proc->max) {
  285.                 snprintf(errmsg, sizeof(errmsg),
  286.                         "Too many %s running (# = %d)",
  287.                         proc->name, (int) long_ret);
  288.             } else if (proc->min == 0 && proc->max == 0 && long_ret < 1) {
  289.                 snprintf(errmsg, sizeof(errmsg),
  290.                         "No %s process running.", proc->name);
  291.             } else {
  292.                 errmsg[0] = 0;
  293.             }
  294.             errmsg[ sizeof(errmsg)-1 ] = 0;
  295.             *var_len = strlen(errmsg);
  296.             return ((u_char *) errmsg);
  297.         case ERRORFIX:
  298.             *write_method = fixProcError;
  299.             long_return = fixproc.result;
  300.             return ((u_char *) & long_return);
  301.         case ERRORFIXCMD:
  302.             if (proc->fixcmd) {
  303.                 *var_len = strlen(proc->fixcmd);
  304.                 return (u_char *) proc->fixcmd;
  305.             }
  306.             errmsg[0] = 0;
  307.             *var_len = 0;
  308.             return ((u_char *) errmsg);
  309.         }
  310.         return NULL;
  311.     }
  312.     return NULL;
  313. }
  315. int
  316. fixProcError(int action,
  317.              u_char * var_val,
  318.              u_char var_val_type,
  319.              size_t var_val_len,
  320.              u_char * statP, oid * name, size_t name_len)
  321. {
  323.     struct myproc  *proc;
  324.     long            tmp = 0;
  326.     if ((proc = get_proc_instance(procwatch, name[10]))) {
  327.         if (var_val_type != ASN_INTEGER) {
  328.             snmp_log(LOG_ERR, "Wrong type != intn");
  329.             return SNMP_ERR_WRONGTYPE;
  330.         }
  331.         tmp = *((long *) var_val);
  332.         if (tmp == 1 && action == COMMIT) {
  333.             if (proc->fixcmd[0]) {
  334.                 strcpy(fixproc.command, proc->fixcmd);
  335.                 exec_command(&fixproc);
  336.             }
  337.         }
  338.         return SNMP_ERR_NOERROR;
  339.     }
  340.     return SNMP_ERR_WRONGTYPE;
  341. }
  343. static struct myproc *
  344. get_proc_instance(struct myproc *proc, oid inst)
  345. {
  346.     int             i;
  348.     if (proc == NULL)
  349.         return (NULL);
  350.     for (i = 1; (i != (int) inst) && (proc != NULL); i++)
  351.         proc = proc->next;
  352.     return (proc);
  353. }
  355. #ifdef bsdi2
  356. #include <sys/param.h>
  357. #include <sys/sysctl.h>
  359. #define PP(pp, field) ((pp)->kp_proc . field)
  360. #define EP(pp, field) ((pp)->kp_eproc . field)
  361. #define VP(pp, field) ((pp)->kp_eproc.e_vm . field)
  363. /*
  364.  * these are for keeping track of the proc array 
  365.  */
  367. static int      nproc = 0;
  368. static int      onproc = -1;
  369. static struct kinfo_proc *pbase = 0;
  371. int
  372. sh_count_procs(char *procname)
  373. {
  374.     register int    i, ret = 0;
  375.     register struct kinfo_proc *pp;
  376.     static int      mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL };
  378.     if (sysctl(mib, 3, NULL, &nproc, NULL, 0) < 0)
  379.         return 0;
  381.     if (nproc > onproc || !pbase) {
  382.         if ((pbase = (struct kinfo_proc *) realloc(pbase,
  383.                                                    nproc +
  384.                                                    sizeof(struct
  385.                                                           kinfo_proc))) ==
  386.             0)
  387.             return -1;
  388.         onproc = nproc;
  389.         memset(pbase, 0, nproc + sizeof(struct kinfo_proc));
  390.     }
  392.     if (sysctl(mib, 3, pbase, &nproc, NULL, 0) < 0)
  393.         return -1;
  395.     for (pp = pbase, i = 0; i < nproc / sizeof(struct kinfo_proc);
  396.          pp++, i++) {
  397.         if (PP(pp, p_stat) != 0 && (((PP(pp, p_flag) & P_SYSTEM) == 0))) {
  398.             if (PP(pp, p_stat) != SZOMB
  399.                 && !strcmp(PP(pp, p_comm), procname))
  400.                 ret++;
  401.         }
  402.     }
  403.     return ret;
  404. }
  406. #elif OSTYPE == LINUXID
  408. #include <dirent.h>
  409. #include <fcntl.h>
  410. #include <unistd.h>
  412. int
  413. sh_count_procs(char *procname)
  414. {
  415.     DIR *dir;
  416.     char cmdline[512], *tmpc;
  417.     struct dirent *ent;
  418. #ifdef USE_PROC_CMDLINE
  419.     int fd;
  420. #endif
  421.     int len,plen=strlen(procname),total = 0;
  422.     FILE *status;
  424.     if ((dir = opendir("/proc")) == NULL) return -1;
  425.     while (NULL != (ent = readdir(dir))) {
  426.       if(!(ent->d_name[0] >= '0' && ent->d_name[0] <= '9')) continue;
  427. #ifdef USE_PROC_CMDLINE  /* old method */
  428.       /* read /proc/XX/cmdline */
  429.       sprintf(cmdline,"/proc/%s/cmdline",ent->d_name);
  430.       if((fd = open(cmdline, O_RDONLY)) < 0) break;
  431.       len = read(fd,cmdline,sizeof(cmdline) - 1);
  432.       close(fd);
  433.       if(len <= 0) continue;
  434.       cmdline[len] = 0;
  435.       while(--len && !cmdline[len]);
  436.       while(--len) if(!cmdline[len]) cmdline[len] = ' ';
  437.       if(!strncmp(cmdline,procname,plen)) total++;
  438. #else
  439.       /* read /proc/XX/status */
  440.       sprintf(cmdline,"/proc/%s/status",ent->d_name);
  441.       if ((status = fopen(cmdline, "r")) == NULL)
  442.           break;
  443.       if (fgets(cmdline, sizeof(cmdline), status) == NULL) {
  444.           fclose(status);
  445.           break;
  446.       }
  447.       fclose(status);
  448.       cmdline[sizeof(cmdline)-1] = '';
  449.       /* XXX: assumes Name: is first */
  450.       if (strncmp("Name:",cmdline, 5) != 0)
  451.           break;
  452.       tmpc = skip_token(cmdline);
  453.       if (!tmpc)
  454.           break;
  455.       for (len=0;; len++) {
  456. if (tmpc[len] && isgraph(tmpc[len])) continue;
  457. tmpc[len]='';
  458. break;
  459.       }
  460.       DEBUGMSGTL(("proc","Comparing wanted %s against %sn",
  461.                   procname, tmpc));
  462.       if(len==plen && !strncmp(tmpc,procname,plen)) {
  463.           total++;
  464.           DEBUGMSGTL(("proc", " Matched.  total count now=%dn", total));
  465.       }
  466. #endif      
  467.     }
  468.     closedir(dir);
  469.     return total;
  470. }
  472. #elif OSTYPE == ULTRIXID
  474. #define NPROCS 32      /* number of proces to read at once */
  476. extern int      kmem, mem, swap;
  478. #include <sys/user.h>
  479. #include <sys/proc.h>
  480. #include <sys/file.h>
  481. #include <sys/vm.h>
  482. #include <machine/pte.h>
  483. #ifdef HAVE_NLIST_H
  484. #include <nlist.h>
  485. #endif
  487. static struct user *getuser(struct proc *);
  488. static int      getword(off_t);
  489. static int      getstruct(off_t, char *, off_t, int);
  491. static struct nlist proc_nl[] = {
  492.     {"_nproc"},
  493. #define X_NPROC 0
  494.     {"_proc"},
  495. #define X_PROC 1
  496.     {"_proc_bitmap"},
  497. #define X_PROC_BITMAP 2
  498.     {NULL}
  499. };
  501. int
  502. sh_count_procs(char *procname)
  503. {
  504.     int             total, proc_active, nproc;
  505.     int             thisproc = 0;
  506.     int             absolute_proc_number = -1;
  507.     struct user    *auser;
  508.     struct proc    *aproc, *procp;
  509.     unsigned        bitmap;
  510.     struct proc     procs[NPROCS], *procsp;
  511.     static int      inited = 0;
  513.     procp = (struct proc *) getword(proc_nl[X_PROC].n_value);
  514.     nproc = getword(proc_nl[X_NPROC].n_value);
  516.     total = 0;
  517.     for (;;) {
  518.         do {
  519.             while (thisproc == 0) {
  520.                 int             nread;
  521.                 int             psize;
  523.                 if (nproc == 0)
  524.                     return (total);
  526.                 thisproc = MIN(NPROCS, nproc);
  527.                 psize = thisproc * sizeof(struct proc);
  528.                 nproc -= thisproc;
  529.                 if (lseek(kmem, (off_t) procp, L_SET) == -1 ||
  530.                     (nread = read(kmem, (char *) procs, psize)) < 0) {
  531.                     /*
  532.                      * warn("read proc"); 
  533.                      */
  534.                     return (total);
  535.                 } else if (nread != psize) {
  536.                     thisproc = nread / sizeof(struct proc);
  537.                     nproc = 0;
  538.                     /*
  539.                      * warn("read proc: short read"); 
  540.                      */
  541.                 }
  542.                 procsp = procs;
  543.                 procp += thisproc;
  544.             }
  546.             aproc = procsp++;
  547.             thisproc--;
  549.             absolute_proc_number++;
  550.             if ((absolute_proc_number % 32) == 0)
  551.                 bitmap =
  552.                     getword((unsigned int) proc_nl[X_PROC_BITMAP].n_value +
  553.                             ((absolute_proc_number / 32) * 4));
  554.             proc_active =
  555.                 (bitmap & (1 << (absolute_proc_number % 32))) != 0;
  556.             if (proc_active && aproc->p_stat != SZOMB
  557.                 && !(aproc->p_type & SWEXIT))
  558.                 auser = getuser(aproc);
  559.         } while (!proc_active || auser == NULL);
  561.         if (strcmp(auser->u_comm, procname) == 0)
  562.             total++;
  563.     }
  564. }
  566. #define SW_UADDR dtob(getword((off_t)dmap.dm_ptdaddr))
  567. #define SW_UBYTES sizeof(struct user)
  569. #define SKRD(file, src, dst, size)
  570. (lseek(file, (off_t)(src), L_SET) == -1) ||
  571. (read(file, (char *)(dst), (size)) != (size))
  573. static struct user *
  574. getuser(struct proc *aproc)
  575. {
  576.     static union {
  577.         struct user     user;
  578.         char            upgs[UPAGES][NBPG];
  579.     } u;
  580.     static struct pte uptes[UPAGES];
  581.     static struct dmap dmap;
  582.     int             i, nbytes;
  584.     /*
  585.      * If process is not in core, we simply snarf it's user struct
  586.      * from the swap device.
  587.      */
  588.     if ((aproc->p_sched & SLOAD) == 0) {
  589.         if (!getstruct
  590.             ((off_t) aproc->p_smap, "aproc->p_smap", (off_t) & dmap,
  591.              sizeof(dmap))) {
  592.             /*
  593.              * warnx("can't read dmap for pid %d from %s", aproc->p_pid,
  594.              * _PATH_DRUM); 
  595.              */
  596.             return (NULL);
  597.         }
  598.         if (SKRD(swap, SW_UADDR, &u.user, SW_UBYTES)) {
  599.             /*
  600.              * warnx("can't read u for pid %d from %s", aproc->p_pid, _PATH_DRUM); 
  601.              */
  602.             return (NULL);
  603.         }
  604.         return (&u.user);
  605.     }
  607.     /*
  608.      * Process is in core.  Follow p_addr to read in the page
  609.      * table entries that map the u-area and then read in the
  610.      * physical pages that comprise the u-area.
  611.      *
  612.      * If at any time, an lseek() or read() fails, print a warning
  613.      * message and return NULL.
  614.      */
  615.     if (SKRD(kmem, aproc->p_addr, uptes, sizeof(uptes))) {
  616.         /*
  617.          * warnx("can't read user pt for pid %d from %s", aproc->p_pid, _PATH_DRUM); 
  618.          */
  619.         return (NULL);
  620.     }
  622.     nbytes = sizeof(struct user);
  623.     for (i = 0; i < UPAGES && nbytes > 0; i++) {
  624.         if (SKRD(mem, ptob(uptes[i].pg_pfnum), u.upgs[i], NBPG)) {
  625.             /*
  626.              * warnx("can't read user page %u for pid %d from %s",
  627.              * uptes[i].pg_pfnum, aproc->p_pid, _PATH_MEM); 
  628.              */
  629.             return (NULL);
  630.         }
  631.         nbytes -= NBPG;
  632.     }
  633.     return (&u.user);
  634. }
  636. static int
  637. getword(off_t loc)
  638. {
  639.     int             val;
  641.     if (SKRD(kmem, loc, &val, sizeof(val)))
  642.         exit(1);
  643.     return (val);
  644. }
  646. static int
  647. getstruct(off_t loc, char *name, off_t dest, int size)
  648. {
  649.     if (SKRD(kmem, loc, dest, size))
  650.         return (0);
  651.     return (1);
  652. }
  653. #elif OSTYPE == SOLARISID
  655. #ifdef _SLASH_PROC_METHOD_
  657. #include <fcntl.h>
  658. #include <dirent.h>
  660. #include <procfs.h>
  662. /*
  663.  * Gets process information from /proc/.../psinfo
  664.  */
  666. int
  667. sh_count_procs(char *procname)
  668. {
  669.     int             fd, total = 0;
  670.     struct psinfo   info;
  671.     char            fbuf[32];
  672.     struct dirent  *ent;
  673.     DIR            *dir;
  675.     if (!(dir = opendir("/proc"))) {
  676.         snmp_perror("/proc");
  677.         return -1;
  678.     }
  680.     while ((ent = readdir(dir))) {
  681.         if (!strcmp(ent->d_name, "..") || !strcmp(ent->d_name, "."))
  682.             continue;
  684.         snprintf(fbuf, sizeof fbuf, "/proc/%s/psinfo", ent->d_name);
  685.         if ((fd = open(fbuf, O_RDONLY)) < 0) {  /* Continue or return error? */
  686.             snmp_perror(fbuf);
  687.     continue;
  688.         }
  690.         if (read(fd, (char *) &info, sizeof(struct psinfo)) !=
  691.             sizeof(struct psinfo)) {
  692.             snmp_perror(fbuf);
  693.             close(fd);
  694.             closedir(dir);
  695.             return -1;
  696.         }
  698.         if (!info.pr_nlwp && !info.pr_lwp.pr_lwpid) {
  699.             /*
  700.              * Zombie process 
  701.              */
  702.         } else {
  703.             DEBUGMSGTL(("proc","Comparing wanted %s against %sn",
  704.                         procname, info.pr_fname));
  705.             if (!strcmp(procname, info.pr_fname)) {
  706.                 total++;
  707.                 DEBUGMSGTL(("proc", " Matched.  total count now=%dn", total));
  708.             }
  709.         }
  711.         close(fd);
  712.     }
  713.     closedir(dir);
  714.     return total;
  715. }
  717. #else                           /* _SLASH_PROC_METHOD_ */
  719. #define _KMEMUSER               /* Needed by <sys/user.h> */
  721. #include <kvm.h>
  722. #include <fcntl.h>
  723. #include <sys/user.h>
  724. #include <sys/proc.h>
  726. int
  727. sh_count_procs(char *procname)
  728. {
  729.     struct proc    *p;
  730.     struct user    *u;
  731.     int             total;
  733.     if (kd == NULL) {
  734.         return -1;
  735.     }
  736.     if (kvm_setproc(kd) < 0) {
  737.         return (-1);
  738.     }
  739.     kvm_setproc(kd);
  740.     total = 0;
  741.     while ((p = kvm_nextproc(kd)) != NULL) {
  742.         if (!p) {
  743.             return (-1);
  744.         }
  745.         u = kvm_getu(kd, p);
  746.         /*
  747.          * Skip this entry if u or u->u_comm is a NULL pointer 
  748.          */
  749.         if (!u) {
  750.             continue;
  751.         }
  752.         if (strcmp(procname, u->u_comm) == 0)
  753.             total++;
  754.     }
  755.     return (total);
  756. }
  757. #endif                          /* _SLASH_PROC_METHOD_ */
  758. #else
  759. int
  760. sh_count_procs(char *procname)
  761. {
  762.     char            line[STRMAX], *cptr, *cp;
  763.     int             ret = 0, fd;
  764.     FILE           *file;
  765. #ifndef EXCACHETIME
  766. #endif
  767.     struct extensible ex;
  768.     int             slow = strstr(PSCMD, "ax") != NULL;
  770.     strcpy(ex.command, PSCMD);
  771.     if ((fd = get_exec_output(&ex)) >= 0) {
  772.         if ((file = fdopen(fd, "r")) == NULL) {
  773.             setPerrorstatus("fdopen");
  774.             close(fd);
  775.             return (-1);
  776.         }
  777.         while (fgets(line, sizeof(line), file) != NULL) {
  778.             if (slow) {
  779.                 cptr = find_field(line, 5);
  780.                 cp = strrchr(cptr, '/');
  781.                 if (cp)
  782.                     cptr = cp + 1;
  783.                 else if (*cptr == '-')
  784.                     cptr++;
  785.                 else if (*cptr == '[') {
  786.                     cptr++;
  787.                     cp = strchr(cptr, ']');
  788.                     if (cp)
  789.                         *cp = 0;
  790.                 }
  791.                 copy_nword(cptr, line, sizeof(line));
  792.                 cp = line + strlen(line) - 1;
  793.                 if (*cp == ':')
  794.                     *cp = 0;
  795.             } else {
  796.                 if ((cptr = find_field(line, LASTFIELD)) == NULL)
  797.                     continue;
  798.                 copy_nword(cptr, line, sizeof(line));
  799.             }
  800.             if (!strcmp(line, procname))
  801.                 ret++;
  802.         }
  803.         if (ftell(file) < 2) {
  804. #ifdef USING_UCD_SNMP_ERRORMIB_MODULE
  805.             seterrorstatus("process list unreasonable short (mem?)", 2);
  806. #endif
  807.             ret = -1;
  808.         }
  809.         fclose(file);
  810.         wait_on_exec(&ex);
  811.     } else {
  812.         ret = -1;
  813.     }
  814.     return (ret);
  815. }
  816. #endif