binary.cpp

来自「包含客户和服务器的升级程序,在linux下可以运行的.」· C++ 代码 · 共 200 行

/*
 * Copyright (C) 2006, Binary Ma
 * Licence: GNU GPL 1991 - version 2
 * Bug report: [e-mail]
*/

#include "binary.h"
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#include <errno.h>

void error( const char* FILE, const char* FUNCTION, int LINE )
{
    fprintf( stderr, "%s->%s( %i ): %s\n", FILE, FUNCTION, LINE, strerror( errno ) );
}

int todaemon()
{
    pid_t pid;
    pid = fork();
    if( pid < 0 )
        return -1;

    if( pid > 0 )
        _exit( pid );
	
    if( -1 == setsid() )
        exit( -1 );
	
    int fd = open( "/dev/null", O_RDWR );
    if( -1 != fd )
    {
        for( int i = 0; i < 3; i++ )
        {
            close( i );
            dup2( fd, i );
        }
		
        close( fd );
    }

    chdir( "/" );
    umask(0);
    return 0;
}

static int filetype( const char* path, int type )
{
    if( NULL == path )
        return -1;
	
    struct stat st;
    if( -1 == lstat( path, &st ) )
        return -1;
	
    int retval = 1;
    switch( type )
    {
    case 0:
        retval = S_ISREG( st.st_mode );
        break;
		
    case 1:
        retval = S_ISDIR( st.st_mode );
        break;
		
    case 2:
        retval = S_ISLNK( st.st_mode );
        break;
        
    case 3:
        retval = S_ISBLK( st.st_mode );
        break;
        
    case 4:
        retval = S_ISCHR( st.st_mode );
        break;
        
    case 5:
        retval = S_ISFIFO( st.st_mode );
        break;
        
    case 6:
        retval = S_ISSOCK( st.st_mode );
        break;
    }
	
    return !retval;
}

int isreg( const char* path )
{
    return filetype( path, 0 );
}

int isdir( const char* path )
{
    return filetype( path, 1 );
}

int islink( const char* path )
{
    return filetype( path, 2 );
}

int isblk( const char* path )
{
    return filetype( path, 3 );
}

int ischr( const char* path )
{
    return filetype( path, 4 );
}

int isfifo( const char* path )
{
    return filetype( path, 5 );
}

int issock( const char* path )
{
    return filetype( path, 6 );
}

void look( const char* line )
{
    for( unsigned int i = 0; i < strlen( line ); i++ )
    {
        printf( "char: %c->%i\n", line[i], (int)(line[i] ) );
    }
}

void version( const char* version, int size )
{
    if( NULL == version )
        return;

    printf( "version: %s", version );
    if( 0 != size )
        printf( " --bit%i", size * 8 );
	
    printf( "\n" );
}

void codemd5( const char* md5 )
{
    if( NULL == md5 )
        return;
	
    const int LEN_MD5 = 32;
    char buf[LEN_MD5 + 1];
    memset( buf, 0, sizeof( buf ) );
    strncpy( buf, md5, LEN_MD5 );
    printf( "MD5: %s.\n", buf );
}

int regsignal( int signum, void(*catchfun)(int), int sigmask )
{
    struct sigaction sigact;
    memset( &sigact, 0, sizeof( sigact ) );
    if( SIGSTOP == signum )
        sigact.sa_flags = SA_NOCLDSTOP;
	
    sigemptyset( &sigact.sa_mask );
    if( -1 != sigmask )
        sigaddset( &sigact.sa_mask, sigmask );
	
    sigact.sa_handler = catchfun;
    return sigaction( signum, &sigact, NULL );
}

int createtree( const char* path, int mode )
{
    if( NULL == path )
        return -__LINE__;
	
    const char* locate = NULL;
    const char* point = path;
    char create[strlen( path ) + 1];
    while( NULL != ( locate = strchr( point, '/' ) ) )
    {
        int length = locate - path;
        point = locate + 1;
        bzero( create, sizeof( create ) );
        strncpy( create, path, length );
        if( 0 == *create )
            continue;
		
        if( 0 != access( create, F_OK ) && -1 == mkdir( create, mode ) )
            return -__LINE__;
    }
	
    return 0;
}