plora.c

获取unix系统进程信息的功能

/****************************************************************************
history:
  2007/03/06  1.0.0             第一版
  2007/04/19  1.0.1             修改cpu占用率超过100%的问题
  2007/04/25  1.0.2             修改unix下取得系统内存为0的问题
  2007/05/30  1.0.3             增加对取得空数据的处理
  2007/06/13  1.0.4             修改获得目录大小变量溢出的问题
  2007/06/13  1.0.5             修改unix平台取系统内存利用率错误
****************************************************************************/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#ifndef WIN32
#include <strings.h>
#include <unistd.h>
#include <stdarg.h>
#endif

#include "plora.h"
#include "common.h"
#include "utils.h"
#include "glbvar.h"
#include "interface.h"


#ifdef WIN32
BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
	case DLL_THREAD_ATTACH:
	case DLL_THREAD_DETACH:
	case DLL_PROCESS_DETACH:
		break;
	}
    return TRUE;
}
#endif

#ifdef WIN32
int my_printf(HANDLE fd, char *fmt,...)	//写入管道函数
#else
int my_printf(int fd, char *fmt,...)	
#endif
{
    va_list argp;
    char szBuf[2048];

#ifdef WIN32
    DWORD dw;
#endif

    va_start(argp, fmt); 
    vsprintf(szBuf,fmt,argp);
    va_end(argp);

#ifdef WIN32
    if (!WriteFile(fd, szBuf, strlen(szBuf), &dw, 0))
    {
        return -1;
    }
#else
    if (write(fd, szBuf, strlen(szBuf)) < 0)
    {
        return -1;
    }
#endif

    return 0;
}

int chk_opt(char *str, int *count, char *opt, int len)
{
    char *p;
    int i;

    trim_str(str, str);
    memset(opt, 0, len);
    *count = 0;
    p = str;
    p = my_strtok(&str, ",");
    while(p)
    {
        if (*p == 0)
        {
            p = my_strtok(&str, ",");
            continue;
        }
        for (i = 0; g_arrOpt[i].optname; i++)
        {
            if (!strcasecmp(g_arrOpt[i].optname, p))
            {
                if(*count != 0)
                {
                    strcat(opt, ",");
                }
                strcat(opt, p);
                (*count)++;
                break;
            }
        }
        if (!g_arrOpt[i].optname)
        {
            return -1;
        }
        p = my_strtok(&str, ",");		
    }
    return 0;
}

int parse_arg(GlbVar *pGlbVar, const char *sArg)
{
    int argc = 21;
    char *argv[21];
    char szTmp[COM_BUF_LEN];
    int ret;
    int i;
    
    spl_str(sArg, "!", argv, &argc);

    if(argc < 1)
    {
        free_arg(argv, argc);
        return -1;
    }

    for (i = 0; i < argc; i++)
    {
        if (!strcmp(argv[i], "-v"))
        {
            pGlbVar->nShowVer = 1;
        }
        else if (!strcmp(argv[i], "-h"))
        {
            pGlbVar->nShowHelpCn = 1;
        }
        else if (!strcmp(argv[i], "-y"))
        {
            pGlbVar->nShowHelpEn = 1;
        }
        else if (!strcmp(argv[i], "-z"))
        {
            pGlbVar->nSelfTest = 1;
        }
    }

    if (pGlbVar->nShowVer 
        || pGlbVar->nShowHelpCn 
        || pGlbVar->nShowHelpEn 
        || pGlbVar->nSelfTest)
    {
        free_arg(argv, argc);
        return 0;
    }

    for (i = 0; i < argc; i++)
    {
        if((argv[i][0] == '-') || (argv[i][0] == '/')) 
        {
            switch (tolower(argv[i][1])) 
            {
            case 's':
                if(argv[++i] == NULL)
                {
                    free_arg(argv, argc);
                    return -1;
                }
                strcpy(pGlbVar->szOraSid, argv[i]);
                break;
            case 'b':
                if(argv[++i] == NULL)
                {
                    free_arg(argv, argc);
                    return -1;
                }
                if (!strcmp(argv[i], "DBWR")
                    && !strcmp(argv[i], "LGWR")
                    && !strcmp(argv[i], "CKPT")
                    && !strcmp(argv[i], "SMON")
                    && !strcmp(argv[i], "PMON"))
                {
                    free_arg(argv, argc);
                    return -1;
                }
                strcpy(pGlbVar->szOraBgProc, argv[i]);
                break;
            case 'd':
                if(argv[++i] == NULL)
                {
                    free_arg(argv, argc);
                    return -1;
                }
                strcpy(pGlbVar->szDir, argv[i]);
                break;
            case 'o':
                if(argv[++i] == NULL)
                {
                    free_arg(argv, argc);
                    return -1;
                }
                memset(szTmp, 0, COM_BUF_LEN);
                strncpy(szTmp, argv[i], COM_BUF_LEN-1);
                ret = chk_opt(szTmp, &(pGlbVar->nOptCount), pGlbVar->szOperation, COM_BUF_LEN);
                if (ret < 0)
                {
                    free_arg(argv, argc);
                    return -1;
                }
                break;
            case 'x':
                pGlbVar->nLocalTest = 1;
                break;
            case 'g':
                pGlbVar->nDebug = 1;
            default :
                break;
            }
        }
    }

    free_arg(argv, argc);
    return 0;
} 

#ifdef WIN32
PLUGIN_API int exstart(int sock, HANDLE fd, const char *sArg, void **out)
{
    return 0;
}
#else
PLUGIN_API int exstart(int sock, int fd, const char *sArg, void **out)
{
    return 0;
}
#endif

#ifdef WIN32
PLUGIN_API int exend(int sock, HANDLE fd, const char *sArg, void *in)
{
    return 0;
}
#else
PLUGIN_API int exend(int sock, int fd, const char *sArg, void *in)
{
    return 0;
}
#endif

#ifdef WIN32
PLUGIN_API int exproc(int sock, HANDLE fd, const char *sArg, void *in)
#else
PLUGIN_API int exproc(int sock, int fd, const char *sArg, void *in)
#endif
{
    GlbVar glbvar;
    char szBuf[COM_BUF_LEN];
    char szOutput[MAX_BUF_LEN];
    char szErrBuf[MIN_BUF_LEN];
    char *pOpt = NULL;
    char *p = NULL;
    int ret;
    int i;

    memset(&glbvar, 0, sizeof(GlbVar));
#ifdef WIN32
    glbvar.nWinBgProcStat = -1;
#endif

    if (parse_arg(&glbvar, sArg) < 0)
    {
        if (my_printf(fd, "1:parameter error\n") < 0)
        {
            return -2;
        }
        return -1;
    }

    if (glbvar.nShowVer)
    {
        if (my_printf(fd, "%s\n", PLVERSION) < 0)
        {
            return -2;
        }
        return 0;
    }
    if (glbvar.nShowHelpCn)
    {
        if (my_printf(fd, "%s", HELP_CN1) < 0)
        {
            return -2;
        }
		if (my_printf(fd, "%s", HELP_CN2) < 0)
        {
            return -2;
        }
		if (my_printf(fd, "%s", HELP_CN3) < 0)
        {
            return -2;
        }
#ifdef WIN32
	    Sleep(100);
#else
	    usleep(100000);
#endif
		if (my_printf(fd, "%s", HELP_CN4) < 0)
        {
            return -2;
        }
		if (my_printf(fd, "%s", HELP_CN5) < 0)
        {
            return -2;
        }
        return 0;
    }
    if (glbvar.nShowHelpEn)
    {
        if (my_printf(fd, "%s", HELP_EN1) < 0)
        {
            return -2;
        }
		if (my_printf(fd, "%s", HELP_EN2) < 0)
        {
            return -2;
        }
		if (my_printf(fd, "%s", HELP_EN3) < 0)
        {
            return -2;
        }
#ifdef WIN32
	    Sleep(100);
#else
	    usleep(100000);
#endif
		if (my_printf(fd, "%s", HELP_EN4) < 0)
        {
            return -2;
        }
		if (my_printf(fd, "%s", HELP_EN5) < 0)
        {
            return -2;
        }
        return 0;
    }
    if (glbvar.nSelfTest)
    {
        if (my_printf(fd, "0:success\n") < 0)
        {
            return -2;
        }
        return 0;
    }

    p = glbvar.szOperation;
    pOpt = my_strtok(&p, ",");

    if (glbvar.nOptCount == 1)
    {
        for (i = 0; g_arrOpt[i].optname; i++)
        {
            if (!strcasecmp(g_arrOpt[i].optname, pOpt))
            {
                break;
            }
        }
        
        if (g_arrOpt[i].optname)
        {
            memset(szBuf, 0, COM_BUF_LEN);
            ret = g_arrOpt[i].func(&glbvar, szBuf, COM_BUF_LEN, szErrBuf);
            if (!ret)
            {
                if (my_printf(fd, "0:%s\n", szBuf) < 0)
                {
                    return -2;
                }
                return 0;
            }
            else
            {
                if (my_printf(fd, "%s\n", szErrBuf) < 0)
                {
                    return -2;
                }
                return -1;
            }
        }
        else
        {
            if (my_printf(fd, "2:operate error\n"))
            {
                return -2;
            }
            return -1;
        }
    }
	
    memset(szOutput, 0, MAX_BUF_LEN);

    for (i = 0; g_arrOpt[i].optname; i++)
    {
        if (!strcasecmp(g_arrOpt[i].optname, pOpt))
        {
            break;
        }
    }
    if (g_arrOpt[i].optname)
    {
        memset(szBuf, 0, COM_BUF_LEN);
        ret = g_arrOpt[i].func(&glbvar, szBuf, COM_BUF_LEN, szErrBuf);
        if (!ret)
        {
            strcpy(szOutput, szBuf);
        }
        else
        {
            strcpy(szOutput, "-1");
        }
    }
    else
    {
        if (my_printf(fd, "2:operate error\n") < 0)
        {
            return -2;
        }
        return -1;
    }

    pOpt = my_strtok(&p, ",");
    while(pOpt)
    {
        for (i = 0; g_arrOpt[i].optname; i++)
        {
            if (!strcasecmp(g_arrOpt[i].optname, pOpt))
            {
                break;
            }
        }
        if (g_arrOpt[i].optname)
        {
            memset(szBuf, 0, COM_BUF_LEN);
            ret = g_arrOpt[i].func(&glbvar, szBuf, COM_BUF_LEN, szErrBuf);
            if (!ret)
            {
                sprintf(szOutput, "%s,%s", szOutput, szBuf);
            }
            else
            {
                sprintf(szOutput, "%s,-1", szOutput);
            }
        }
        else
        {
            if (my_printf(fd, "2:operate error\n") < 0)
            {
                return -2;
            }
            return -1;
        }
        pOpt = my_strtok(&p, ",");		
    }

    if (my_printf(fd, "0:%s\n", szOutput) < 0)
    {
        return -2;
    }

    return 0;
}