데몬의 메모리 누수문제

관심과 답변 갑사합니다.

일반애플리케이션도 루프를 돌면서 프로그램이 실행됩니다.

데몬이랑 동일하게 동작하구요

메모리 문제는 큐를 미리 할당하기 때문에...더이상 체크할 곳이 없습니다.
큐에서 읽어올때 아래와 같이 읽어오는 방식이거든요

void * thread_start_func(void *arg)
{
       struct _tag  elem ;// statck에 메모리가 할당되구
       deque(&elem);      // 큐에서 읽은값을 elem 주소에  복사해줍니다.
}

아무튼 관심과 답변 갑사합니다.

#ifdef _DAEMON
daemon_init();// 포크하고 시그널 무시하는 등 데몬의 기본 동작수행
#endif

데몬으로 컴파일할때는 위의 코드가 컴파일이 됩니다.
그리구 차이점이라면 데몬일때 로그내용이 파일에 저장되는 것인데요
(일반 애플리케이션일때는 그냥 stdout으로)

그렇다면 로그내용이 파일에 저장될때 메모리 누수가 발생하는가 싶은 생각이 들어서
로그를 아예 남기지 않도록 테스트를 해보았습니다.
그래도 마찬가지였습니다.

제가 아는 차이점에 대해서는 다 테스트해보았는데 더 이상은 모르겠네요
위의 경우에 발생가능한... 실수 또는 오류가 어떤것이 있는지 궁금합니다.

답변 감사드립니다.

사족) 이런거 보면 자바가 얼마나 편한건지..새삼 느낍니다.
메모리가 부족하면 램하나 추가하면 되거든요
안전한 프로그램이 램값보다 중요하니까.. 이휴

이 긴글을 읽어주실분이 계실런지..

일단............. ipc,regex는 사용하지 않습니다.
바로 윗글을 읽고...혹시 시간관련..라이브러리에서
내부적으로 메모리 누수의 문제가 있지는 않나 궁금해지는군요

원하신다면 전체소스도 공개해드립니다. ㅠㅠ

버그를 찾기만 하면 삼선짬뽕은 제가 사드릴께요.. 진짜 사드림 ㅎㅎ (단, 버그찾아주시면 ㅋㅋ)

일단 시스템 초기화시에 큐 메모리를 할당해 놓으므로 더이상의 malloc은 없습니다. (적어도 제가 직접 malloc 하지는 않습니다)

그리고 네트워크 관련 함수들은 스티븐스아저씨의 소스를 그대로 카피해왔으므로 버그의 가능성에서 제외시켜보겠습니다.(하지만 맨밑에 첨부는 했음)

그 다음... 시간관련 라이브러리에 문제가 있지 않을까 생각이 듭니다. 시간관련 라이브러리에 대해 제가 정확히 그 내부동작을 이해하는 것은 아니라서.. 조금 의심이 가는군요.

디버깅을 위해 아래와 같은 매크로를 선언했습니다.

////////////////////////////////////////////////////////////
// DUMP LEVEL
#define DBG_DUMP(fmt,args...)    \
do{ \
    if(__global_log_level & LOG_LEVEL_DUMP) \
        log_msg(__global_dump_file,"DUMP : %u %s (%s@%d) "fmt,\
                time(NULL),kidi_formattime(timebuf),__FILE__,__LINE__,##args); \
}while(0)


참고로 변수 timebuf는 모든 함수마다 시작부분에서 
char timebuf[128]; 이라고 선언해두고 사용합니다.

char *kidi_formattime(char *logtime)
{
    return format_time(logtime, 128, "%Y년%m월%d일 %H시%M분%S초");
}

char *format_time(char *buf, int size, const char *fmt)
{
    struct tm   st_tm ;
    time_t       tim;
    tim   = time(NULL);
    localtime_r(&tim, &st_tm);
    strftime(buf, size, fmt , &st_tm);
    return buf;
}

로그관련 함수들을 정의해놓은 파일 log.c는 아래와 같습니다.
로그파일 이름은 예를 들면 a.20050228.2644.0 인데
a.날짜.ProcessId.일련번호 입니다.
일련번호는 20메가 이상이면 일련번호가 증가합니다.

#include "libcomm.h"


char g_today[20]="00000000";
int  g_today_index = 0;

static void log_doit(int , const char *, va_list , char *);


void log_err(char *logfile, const char *fmt, ...)
{
    va_list ap;
    va_start(ap,fmt);
    log_doit(1,fmt,ap,logfile);
    va_end(ap);
    return ;
}


void log_msg(char *logfile, const char *fmt, ... )
{
    va_list ap;
    va_start(ap,fmt);
    log_doit(0,fmt,ap,logfile);
    va_end(ap);
    return ;
}


static void log_doit ( int errnoflag, 
        const char *fmt, va_list ap, char *logfile)
{
    int errno_save;
    char buf[ LOGMSG_MAX ];
    char filename_buf[ 256 ];
    char timebuf[128];
    int fd;

    errno_save = errno;
    buf[0]=0;
    sprintf(buf,"[%6ld] ",getpid());
    vsprintf(buf + strlen(buf), fmt, ap);
    if(errnoflag)
        sprintf(buf+strlen(buf),": %s", strerror(errno_save));
    strcat(buf,"\n");
    fd = open_log_file(logfile,filename_buf,128);
    if( fd >= 0)
    {
        errno = 0;
        if( write(fd, buf, strlen(buf)) < 0)
        {
            syslog(LOG_ERR,"write(%d,size:%d, %s): %s\n", fd,strlen(buf),filename_buf,strerror(errno));
        }
    }
    else
        syslog(LOG_ERR,"open(%s,O_APPEND|O_CREAT,0644) fail:%s\n", filename_buf,strerror(errno));

    close(fd);

    return ;
}



int open_log_file(char *filename_prefix,char *filename_buf, int bufsize)
{
    time_t       tim;
    tim = time(NULL);
    char timebuf[128];
    struct stat stat_buf;
    int fd;

    do
    {
        log_yyyymmdd(timebuf, sizeof(timebuf));
        if( strncmp( g_today, timebuf, 8) != 0)
        {   
            // 날자가 변동되었음
            g_today_index = 0;
            strncpy(g_today, timebuf,8);
        }


        sprintf(filename_buf,"%s.%s.%ld.%d",filename_prefix, g_today,getpid(),g_today_index);
        
        if( stat(filename_buf,&stat_buf) == 0)// 성공
        {
            if( stat_buf.st_size > 20000000) // 로그 파일의 최대크기는 20메가로 정했음
            {
                g_today_index++;
                continue;
            }
            else
            {
                fd = open(filename_buf,O_WRONLY|O_APPEND|O_CREAT,0664);
                break;
            }
        }
        else
        {
            g_today_index = 0;
            fd = open(filename_buf,O_WRONLY|O_APPEND|O_CREAT,0664);
            break;
        }
    } while(1);

    return fd;
}

char *log_yyyymmdd(char *buf, int bufsize)
{
    struct tm   st_tm ;
    time_t       tim;
    tim   = time(NULL);
    localtime_r(&tim, &st_tm);
    strftime(buf,bufsize,"%Y%m%d", &st_tm);
    return buf;
}

참고로
스티븐스아저씨의 소스코드를 긁어서 나름대로 만든 소스도
첨부시켜드립니다.

#include "libcomm.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/file.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>


// 안전한 방법으로 disconnect 한다.
// 리턴값은 마지막으로 읽은 데이타의 바이트수이다
int safe_disconnect( int sock )
{
    if( sock < 0) 
        return -1;
    close(sock);
}   
    


int tcp_connect_timeo(const char *hostname, const char *service,int nsec)
{
    struct addrinfo hints, *res, *ressave;
    int  sock,n; 

    bzero(&hints, sizeof(struct addrinfo));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    if( (n=getaddrinfo(hostname,service,&hints,&res)) != 0) 
        return -1;
    ressave = res;
    do
    {   // 소켓 생성
    	struct  sockaddr_in *ts;
        sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
        if(sock < 0)
            continue;

        ts = (struct sockaddr_in *) res->ai_addr;

        // 연결요청
        if(connect_nonb(sock, (struct sockaddr *)res->ai_addr, res->ai_addrlen,nsec) == 0)
            break;
        close(sock);
    }while( (res=res->ai_next) !=NULL);
    if( res == NULL)
        return -1;
    freeaddrinfo(ressave);
    return sock;
}


struct addrinfo * 
host_serv(const char *hostname, const char *service, int family, int socktype)
{
    int     n;
    struct addrinfo hints, *res;
    bzero(&hints, sizeof(struct addrinfo));
    hints.ai_flags = AI_CANONNAME;
    hints.ai_family = family;
    hints.ai_socktype = socktype;

    if( (n=getaddrinfo(hostname,service,&hints,&res)) != 0)
        return NULL;
    return res;
}


const char *num2ipstr(const u_char *src, char *dst, size_t size)
{
    static const char fmt[] = "%u.%u.%u.%u";
    char tmp[sizeof "255.255.255.255"];

    sprintf(tmp, fmt, src[0], src[1], src[2], src[3]);
    if (strlen(tmp) > size) {
        errno = ENOSPC;
        return (NULL);
    }
    strcpy(dst, tmp);
    return (dst);
}


int tcp_connect(const char *hostname, const char *service)
{
    struct addrinfo hints, *res, *ressave;
    int  sock,n; 

    bzero(&hints, sizeof(struct addrinfo));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    if( (n=getaddrinfo(hostname,service,&hints,&res)) != 0) 
        return -1;
    ressave = res;
    do
    {   // 소켓 생성
    	struct  sockaddr_in *ts;
        sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
        if(sock < 0)
            continue;

        ts = (struct sockaddr_in *) res->ai_addr;

        // 연결요청
        if(connect(sock, res->ai_addr, res->ai_addrlen) == 0)
            break;
        close(sock);
    }while( (res=res->ai_next) !=NULL);
    if( res == NULL)
        return -1;
    freeaddrinfo(ressave);
    return sock;
}


// listen 소켓 생성 및 listen
int tcp_listen(const char *host, const char *serv, socklen_t *addrlenp)
{
    int             listenfd, n;
    const int       on = 1;
    struct addrinfo hints, *res, *ressave;

    bzero(&hints, sizeof(struct addrinfo));
    hints.ai_flags = AI_PASSIVE;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    if ( (n = getaddrinfo(host, serv, &hints, &res)) != 0)
    {
        return -1;
    }

    ressave = res;
    do 
    {
        listenfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
        if (listenfd < 0)
            continue;       /* error, try next one */

        if( setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)))
        {
            err_sys("setsockopt fail,for %s, %s: %s", 
                    host, serv, gai_strerror(n));
        }

        if (bind(listenfd, res->ai_addr, res->ai_addrlen) == 0)
            break;          /* success */

        close(listenfd);    /* bind error, close and try next one */
    } while ( (res = res->ai_next) != NULL);

    if (res == NULL)    /* errno from final socket() or bind() */
    {
        err_sys("tcp_listen error for %s, %s", host, serv);
        freeaddrinfo(ressave);
        return -1;
    }
    listen(listenfd, 1024);
    if (addrlenp)/* return size of protocol address */
        *addrlenp = res->ai_addrlen;    

    freeaddrinfo(ressave);
    return(listenfd);
}

int connect_nonb(int sockfd, const struct sockaddr *saptr, int salen, int nsec)
{
	int				flags, n, error;
	socklen_t		len;
	fd_set			rset, wset;
	struct timeval	tval;
    if( sockfd < 0) 
        return -1;

	flags = fcntl(sockfd, F_GETFL, 0);
	fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);

	error = 0;
	if ( (n = connect(sockfd, (struct sockaddr *) saptr, salen)) < 0)
		if (errno != EINPROGRESS)
			return(-1);

	/* Do whatever we want while the connect is taking place. */

	if (n == 0)
		goto done;	/* connect completed immediately */

	FD_ZERO(&rset);
	FD_SET(sockfd, &rset);
	wset = rset;
	tval.tv_sec = nsec;
	tval.tv_usec = 0;

	if ( (n = select(sockfd+1, &rset, &wset, NULL,
					 nsec ? &tval : NULL)) == 0) {
		close(sockfd);		/* timeout */
		errno = ETIMEDOUT;
		return(-1);
	}

	if (FD_ISSET(sockfd, &rset) || FD_ISSET(sockfd, &wset)) {
		len = sizeof(error);
		if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) < 0)
			return(-1);			/* Solaris pending error */
	} else
		err_quit("select error: sockfd not set");

done:
	fcntl(sockfd, F_SETFL, flags);	/* restore file status flags */

	if (error) {
		close(sockfd);		/* just in case */
		errno = error;
		return(-1);
	}
	return(0);
}

int readable_timeo(int fd, int sec)
{
    fd_set rset;
    struct timeval tv;
    if( fd < 0) 
        return -1;
    FD_ZERO(&rset);
    FD_SET(fd, &rset);
    tv.tv_sec = sec;
    tv.tv_usec = 0;
    return (select (fd+1, &rset, NULL, NULL, &tv) );
}

int tcp_timedread(int fd,char *buf,int bufsize, int sec)
{
    int   ret;

    if( fd < 0) 
        return -1;
    if( (ret=readable_timeo(fd, sec)) > 0)
    {
        return read(fd, buf,bufsize);
    }
    else if( ret == 0 ) // timeout
    {
        return 0;
    }
    else //if( ret < 0 ) // error (interrupt or other signal)
        return -1;
}

int tcp_timedreadn(int fd,char *buf,int nbyte, int sec)
{
    int   ret;
    if( fd < 0) 
        return -1;
    if( (ret=readable_timeo(fd, sec)) > 0)
    {
        return readn(fd, buf,nbyte);
    }
    else if( ret == 0 ) // timeout
    {
        return 0;
    }
    else
        return -1;
}