util.cpp

一个3D桌面的实现源码

    } else {
        //msgout (DEBUG, "CREATED!\n");

        // we must init to zero since there is no gaurantee of its
        // initial value.  this is the fatal flaw of sysV ipc.
        // Stevens provides an algorithm to make initialization
        // safe (just initializing it is not technically safe) but
        // this race is very unlikely (I hope!)
        semstat.val = 0;
        if ( semctl (semid, 0, SETVAL, semstat ) < 0 )
        {
            msgout (ERROR, "semctl SETVAL zero failed: %d: %s\n",
                    errno, strerror(errno));
            return 1;
        }
    }

    return 0;
}


int flag_that_i_am_running(void)
{

    // I like using a semaphore for this purpose because it will
    // automatically be decremented for us when we exit - regardless
    // of how the process was killed plus I have knowledge about this
    // sys V crap ;)

    // btw can't use POSIX sem_init etc here because linux doesn't do
    // inter-process apparently... :(   (whats the use?)

    union semun {
        int val;                    /* value for SETVAL */
        struct semid_ds *buf;       /* buffer for IPC_STAT, IPC_SET */
        unsigned short int *array;  /* array for GETALL, SETALL */
        struct seminfo *__buf;      /* buffer for IPC_INFO */
    } semstat;

    int rc;
    key_t key = 0;
    int semid = 0;
    struct sembuf chain_lock[2];

    key = ftok("/bin/sh", 99);
    if (key < 0) {
        msgout(ERROR,"ftok failed: %d: %s\n", errno, strerror(errno));
        return 1;
    }


    semid = semget(key, 1, 0666 | IPC_CREAT | IPC_EXCL );
    if (semid < 0) {
        // if the semaphore exists read it and if its non-zero fail
        if (errno == EEXIST) {
            //msgout (DEBUG,"EXISTS!\n");

            semid = semget(key, 1, 0666);
            if (semid < 0) {
                msgout(ERROR,"semget (2) failed: %d: %s\n",
                        errno, strerror(errno));
                return 1;
            }
    
        } else {
            // semget failed for some weird reason
            msgout(ERROR, "semget failed: %d: %s\n", errno, strerror(errno));
            return 1;
        }
    } else {
        // this should never happen since we created in
        // check_if_i_am_running() above....

        //msgout (DEBUG, "CREATED!\n");

        // we must init to zero since there is no gaurantee of its
        // initial value.  this is the fatal flaw of sysV ipc.
        // Stevens provides an algorithm to make initialization
        // safe (just initializing it is not technically safe) but
        // this race is very unlikely (I hope!)
        semstat.val = 0;
        if ( semctl (semid, 0, SETVAL, semstat ) < 0 )
        {
            msgout (ERROR, "semctl SETVAL zero failed: %d: %s\n",
                    errno, strerror(errno));
            return 1;
        }
    }
    
#if 0
    if ( (rc = semctl (semid, 0, GETVAL, semstat )) < 0 )
    {
        msgout (ERROR, "semctl GETVAL zero failed: %d: %s\n",
                errno, strerror(errno));
        return 1;
    }
    msgout (DEBUG, "sem value == %d\n", rc);
#endif

    // we either just created the semaphore or we got a handle to the
    // existing one ... init it to 1 atomically and we're golden
        
    // check if its zero and if its zero increment to 1
    // atomically - SEM_UNDO will reset when process dies
    chain_lock[0].sem_num = 0;
    chain_lock[0].sem_op  = 0;
    chain_lock[0].sem_flg = IPC_NOWAIT;
    chain_lock[1].sem_num = 0;
    chain_lock[1].sem_op  = 1;
    chain_lock[1].sem_flg = SEM_UNDO | IPC_NOWAIT;
    
    rc = semop(semid, &chain_lock[0], 2);
    if ( rc < 0 ) {
        if (errno == EAGAIN) {
            // would block meaning the semaphore is non-zero
            // so somebody else has it - return 1 :(
            return 1;
        } else {
            msgout (ERROR, "semop failed: %d: %s\n", errno,
                    strerror(errno));
            return 1;
        }
    }
    
    // we successfully incremented to 1 - we're golden
    return 0;

#ifdef FILE_METHOD

    FILE *fp = NULL;
    struct stat statbuf;

    sprintf(running_file, "%s/running", cfg->options->working_dir);

    if (stat(running_file, &statbuf) < 0) {
        fp = fopen (running_file, "w");
        if (fp == NULL) {
            msgout (ERROR, "Could not create %s: %s\n", running_file, strerror(errno));
            return 1;
        }
        fclose (fp);
    } else {
        // file exists so fail
        return 1;
    }

    return 0;
#endif

}

int flag_that_i_am_NOT_running(void)
{
#ifdef FILE_METHOD
    if (running_file[0] != 0)
        // just delete the file
        unlink (running_file);
#endif

    return 0;
}



//-------------------------------------------------
//  Functions used by faceset.cpp
//-------------------------------------------------



// calculates the points in an n-sided polygon
void calculate_polypoints (int num, float side_len, polypoints_t *pp) 
{
    int i;
    float side_angle = 360.0 / (float)num;

    float r = (side_len/2.0) / sin(deg_to_rad(side_angle/2.0));

    float theta = -side_angle/2.0 - 90.0;  // to start

    //msgout(DEBUG,"r = %lf, theta = %lf\n", r, theta);

    for (i = 0; i < num; i++) {
        pp->x[i] = polar_to_x (r, theta);
        pp->y[i] = polar_to_y (r, theta);

        theta += side_angle;
    }
}



void translate (vertex_t v, float x, float y, float z)
{
    v[0] += x;
    v[1] += y;
    v[2] += z;
}

// multiply m times v and put result in v
static void multiply (matrix_t m, vertex_t v) 
{
    vertex_t r;
    r[0] =  m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2] + m[0][3] * v[3];
    r[1] =  m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2] + m[1][3] * v[3];
    r[2] =  m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2] + m[2][3] * v[3];
    r[3] =  m[3][0] * v[0] + m[3][1] * v[1] + m[3][2] * v[2] + m[3][3] * v[3];
    v[0] = r[0];
    v[1] = r[1];
    v[2] = r[2];
    v[3] = r[3];
}


static void load_identity (matrix_t m)
{
    memset(m, 0, sizeof(matrix_t));
    m[0][0] = m[1][1] = m[2][2] = m[3][3] = 1.0;
}


//      Rotation

//         | 1      0        0   0 |
// Rx(A) = | 0  cos A   -sin A   0 |
//         | 0  sin A    cos A   0 |
//         | 0      0        0   1 |
 
//         | cos A   0   sin A   0 |
// Ry(A) = |     0   1       0   0 |
//         | -sin A  0   cos A   0 |
//         |     0   0       0   1 |

//         | cos A  -sin A   0   0 |
// Rz(A) = | sin A   cos A   0   0 |
//         |     0       0   1   0 |
//         |     0       0   0   1 |

void rotate_x (vertex_t v, float x)
{
    float xr = deg_to_rad(x);
    float tmp;
    matrix_t m;

    // x
    load_identity (m);
    tmp = cos(xr);
    m[1][1] = tmp;
    m[2][2] = tmp;
    tmp = sin(xr);
    m[1][2] = -tmp;
    m[2][1] = tmp;

    multiply (m, v);
}
    
void rotate_y (vertex_t v, float y)
{
    float yr = deg_to_rad(y);
    float tmp;
    matrix_t m;

    // y
    load_identity (m);
    tmp = cos(yr);
    m[0][0] = tmp;
    m[2][2] = tmp;
    tmp = sin(yr);
    m[0][2] = tmp;
    m[2][0] = -tmp;


    multiply(m,v);
}
void rotate_z (vertex_t v, float z)
{
    float zr = deg_to_rad(z);
    float tmp;
    matrix_t m;

    // z
    load_identity (m);
    tmp = cos(zr);
    m[0][0] = tmp;
    m[1][1] = tmp;
    tmp = sin(zr);
    m[0][1] = -tmp;
    m[1][0] = tmp;

    multiply(m,v);
}



int daemon_init (void)
{
    pid_t pid;

    msgout (DEBUG, "daemon init\n");
    
    if ( (pid = fork()) < 0) {
        msgout (ERROR, "daemon_init: fork failed: %s\n", strerror(errno));
        return -1;
    } else if (pid != 0) {
        msgout (INFO, "Daemon started.  Run 3ddesk to activate.\n");
        exit(0);  // bye parent
    }

    // child continues 

    setsid();
    
    chdir ("/");

    umask (0);

    return(0);
} // END daemon_init 



extern MessageManager msgmgr;


void end_program (int rv)
{
    flag_that_i_am_NOT_running();

    if (cfg)
        delete cfg;

    if (msgmgr.close() < 0)
        msgout(ERROR, "Could not delete message queue: %s\n", strerror(errno));

    exit (rv);
}