Exemple #1
0
/** Move current client to other workspace
 */
void push(const struct arg_t *arg) {
    struct workspace_t *src, *dst;

    if (arg->u == nil_.ws_idx) {        /* same workspace */
        return;
    }
    src = &nil_.ws[nil_.ws_idx];
    if (!src->focus) {
        return;
    }
    dst = &nil_.ws[arg->u];
    /* move client and hide it */
    detach_client(src->focus);
    attach_client(src->focus, dst);
    hide_client(src->focus);
    src->focus = 0;
    /* rearrange and update new workspace indicator */
    arrange_ws(src);
    update_bar_ws(arg->u);
}
Exemple #2
0
int main(int argc, char* argv[])
{
    int opt, ret;
    int daemon = 1, lock = 0;
    int screen_status, aux_pressed, power_pressed, y, x;
    char *config;
    FILE *file;
    struct sockaddr_un addr;
    
    struct chain_socket *aux_grabber = 0, *power_grabber = 0;
    
    struct input_event input;
    struct iod_cmd cmd;
    struct chain_socket *cs;
    
    size_t size;
    
    y = x = screen_status = aux_pressed = power_pressed = 0;
    pwd = IOD_PWD;
    
    while((opt = getopt(argc, argv, "fd:")) != -1)
    {
        switch(opt)
        {
        case 'f':
            daemon = 0;
            break;
        case 'd':
            pwd = optarg;
            break;
        default:
            usage(argv[0]);
            return 0;
        }
    }
    
    if(optind == argc)
    {
        usage(argv[0]);
        return 0;
    }
    
    config = argv[optind];
    
    if(mkdir(pwd, 0777) == -1 && errno != EEXIST)
    {
        perror("Failed to create working dir");
        return 7;
    }
    
    if(daemon)
    {
        int tmp = fork();
        if(tmp < 0)
        {
            perror("Failed to fork process");
            return 1;
        }
        if(tmp > 0)
        {
            return 0;
        }
        
        setsid();
        
        close(0); close(1); close(2);
        tmp = open("/dev/null", O_RDWR); dup(tmp); dup(tmp);
        
        chdir(pwd);
        
        if((tmp = open("pid", O_WRONLY|O_CREAT, 755)) < 0)
        {
            perror("Failed to open pidfile");
            return 2;
        }
        
        pid_t pid = getpid();
        char buf[10];
        int count = sprintf(buf, "%i", pid);
        write(tmp, &buf, count*sizeof(char));
        
        if(lockf(tmp, F_TLOCK, -count*sizeof(char)) < 0)
        {
            perror("Daemon already running");
            return 3;
        }
    }
    
    if(!(file = fopen(config, "r")))
    {
        perror("Failed to open config file");
        return 4;
    }
    
    if((size = getline(&screen_dev, &size, file)) == -1)
    {
        fprintf(stderr, "Failed to read screen config\n");
        return 5;
    }
    screen_dev[size-1] = 0;
    
    if((screen_fd = open(screen_dev, O_RDONLY)) == -1)
    {
        perror("Failed to open screen socket");
        return 6;
    }
    
    if((size = getline(&aux_dev, &size, file)) == -1)
    {
        fprintf(stderr, "Failed to read aux config\n");
        return 7;
    }
    aux_dev[size-1] = 0;
    
    if((aux_fd = open(aux_dev, O_RDONLY)) == -1)
    {
        perror("Failed to open aux socket");
        return 8;
    }
    
    if((size = getline(&power_dev, &size, file)) == -1)
    {
        fprintf(stderr, "Failed to read power config\n");
        return 9;
    }
    power_dev[size-1] = 0;
    fclose(file);
    
    if((power_fd = open(power_dev, O_RDONLY)) == -1)
    {
        perror("Failed to open power socket");
        return 10;
    }
    
    DEBUG(print_info(screen_fd));
    DEBUG(print_info(aux_fd));
    DEBUG(print_info(power_fd));
    
    if((ret = open_socket(&sock, &addr)))
        return ret;
    
    pfds_cap = 10;
    pfds = malloc(pfds_cap*sizeof(struct pollfd));
    pfds[0].fd = screen_fd;
    pfds[0].events = POLLIN;
    pfds[1].fd = aux_fd;
    pfds[1].events = POLLIN;
    pfds[2].fd = power_fd;
    pfds[2].events = POLLIN;
    pfds[3].fd = sock;
    pfds[3].events = POLLIN;
    
    client_count = 0;
    CIRCLEQ_INIT(&client_list);
    
    signal(SIGINT, signal_handler);
    
    DEBUG(printf("Ready\n"));
    
    while(1)
    {
        poll(pfds, client_count+4, -1);
        
        if(pfds[0].revents & POLLHUP || pfds[0].revents & POLLERR)
        {
            DEBUG(printf("pollhup/err on screen socket\n"));
            close(screen_fd);
            if((screen_fd = open(screen_dev, O_RDONLY)) < 0)
            {
                perror("Failed to open screen socket");
                screen_fd = 0;
                cleanup();
                return 6;
            }
        }
        else if(pfds[0].revents & POLLIN)
        {
            read(screen_fd, &input, sizeof(struct input_event));
            
            if(lock)
                continue;
            
            switch(input.type)
            {
            case EV_KEY:
                switch(input.code)
                {
                case BTN_TOUCH:
                    switch(input.value)
                    {
                        case 0:
                            screen_status = 0;
                            break;
                        case 1:
                            screen_status = 1;
                            break;
                    }
                    break;
                }
                break;
            case EV_ABS:
                switch(input.code)
                {
                case ABS_X:
                    y = input.value-MIN_PIXEL;
                    break;
                case ABS_Y:
                    x = input.value-MIN_PIXEL;
                    break;
                case ABS_PRESSURE:
                    break;
                }
                break;
            case EV_SYN:
                switch(input.code)
                {
                case SYN_REPORT:
                    switch(screen_status)
                    {
                    case 0:
                        DEBUG(printf("Touchscreen released (%i,%i)\n", y, x));
                        send_client_cord(IOD_EVENT_RELEASED, y, x, 0);
                        break;
                    case 1:
                        DEBUG(printf("Touchscreen pressed (%i,%i)\n", y, x));
                        send_client_cord(IOD_EVENT_PRESSED, y, x, 0);
                        screen_status = 2;
                        break;
                    case 2:
                        send_client_cord(IOD_EVENT_MOVED, y, x, 0);
                        break;
                    }
                    break;
                }
                break;
            }
        }
        else if(pfds[1].revents & POLLHUP || pfds[1].revents & POLLERR)
        {
            DEBUG(printf("pollhup/err on aux socket\n"));
            close(aux_fd);
            if((aux_fd = open(aux_dev, O_RDONLY)) == -1)
            {
                perror("Failed to open aux socket");
                aux_fd = 0;
                cleanup();
                return 8;
            }
        }
        else if(pfds[1].revents & POLLIN)
        {
            read(aux_fd, &input, sizeof(struct input_event));
            switch(input.type)
            {
            case EV_KEY:
                switch(input.code)
                {
                case KEY_PHONE:
                    aux_pressed = input.value;
                    break;
                }
                break;
            case EV_SYN:
                switch(input.code)
                {
                case SYN_REPORT:
                    DEBUG(printf("AUX %s\n",
                        aux_pressed ? "pressed" : "released"));
                    cs = aux_grabber ? aux_grabber : 0;
                    send_client_status(IOD_EVENT_AUX, aux_pressed, cs);
                    break;
                }
                break;
            }
        }
        else if(pfds[2].revents & POLLHUP || pfds[2].revents & POLLERR)
        {
            DEBUG(printf("pollhup/err on power socket\n"));
            close(power_fd);
            if((power_fd = open(power_dev, O_RDONLY)) == -1)
            {
                perror("Failed to open power socket");
                power_fd = 0;
                cleanup();
                return 10;
            }
        }
        else if(pfds[2].revents & POLLIN)
        {
            read(power_fd, &input, sizeof(struct input_event));
            switch(input.type)
            {
            case EV_KEY:
                switch(input.code)
                {
                case KEY_POWER:
                    power_pressed = input.value;
                    break;
                }
                break;
            case EV_PWR:
                break;
            case EV_SYN:
                switch(input.code)
                {
                case SYN_REPORT:
                    DEBUG(printf("Power %s\n",
                        power_pressed ? "pressed" : "released"));
                    cs = power_grabber ? power_grabber : 0;
                    send_client_status(IOD_EVENT_POWER, power_pressed, cs);
                    break;
                }
                break;
            }
        }
        else if(pfds[3].revents & POLLHUP || pfds[3].revents & POLLERR)
        {
            DEBUG(printf("pollhup/err on socket\n"));
            close(sock);
            if((ret = open_socket(&sock, &addr)))
            {
                sock = 0;
                cleanup();
                return ret;
            }
        }
        else if(pfds[3].revents & POLLIN)
        {
            int client;
            if((client = accept(sock, 0, 0)) == -1)
            {
                DEBUG(perror("Failed to accept client"));
                continue;
            }
            cs = client_list.cqh_first;
            add_client(client);
            if(cs != (void*)&client_list)
                send_client_status(IOD_EVENT_DEACTIVATED, 0, cs);
            else
                send_client_status(IOD_EVENT_ACTIVATED, 0, 0);
        }
        else
        {
            int x;
            for(x=4; x<client_count+4; x++)
                if(pfds[x].revents & POLLHUP || pfds[x].revents & POLLERR)
                {
                    DEBUG(printf("pollhup/pollerr on client socket [%i]\n", pfds[x].fd));
                    cs = find_client(&x, 0);
remove:             if(cs == aux_grabber)
                    {
                        DEBUG(printf("AUX ungrabbed [%i] %i\n",
                            cs->sock, cs->pid));
                        aux_grabber = 0;
                    }
                    if(cs == power_grabber)
                    {
                        DEBUG(printf("Power ungrabbed [%i] %i\n",
                            cs->sock, cs->pid));
                        power_grabber = 0;
                    }
                    if(cs->lock)
                    {
                        DEBUG(printf("Screen unlocked [%i] %i\n",
                            cs->sock, cs->pid));
                        lock = 0;
                    }
                    if(rem_client(x, cs))
                        send_client_status(IOD_EVENT_ACTIVATED, 0, 0);
                    break;
                }
                else if(pfds[x].revents & POLLIN)
                {
                    if(recv_client(pfds[x].fd, &cmd))
                        break;
                    switch(cmd.cmd)
                    {
                    case IOD_CMD_REGISTER:
                        register_client(x, cmd.pid);
                        break;
                    case IOD_CMD_REMOVE:
                        if((cs = find_client(&x, cmd.pid)))
                        {
                            if(cs->sock == pfds[x].fd)
                                goto remove;
                            else
                            {
                                DEBUG(printf("Client remove [%i] %i\n",
                                    cs->sock, cs->pid));
                                send_client_status(
                                    IOD_EVENT_REMOVED, 0, cs);
                            }
                        }
                        break;
                    case IOD_CMD_SWITCH:
                        cs = client_list.cqh_first;
                        if(switch_client(cmd.value, x, cmd.pid))
                            send_client_status(
                                IOD_EVENT_DEACTIVATED, 0, cs);
                        break;
                    case IOD_CMD_LOCK:
                        cs = find_client(&x, 0);
                        if(!lock || cs->lock)
                        {
                            lock = cs->lock = cmd.value;
                            DEBUG(printf("Screen %s [%i] %i\n",
                                lock ? "locked" : "unlocked",
                                x, cs->pid));
                            send_client_status(
                                IOD_EVENT_LOCK, IOD_SUCCESS_MASK, cs);
                        }
                        else
                            send_client_status(
                                IOD_EVENT_LOCK, 0, cs);
                        break;
                    case IOD_CMD_HIDE:
                        hide_client(x, cmd.pid,
                            cmd.value & ~IOD_HIDE_MASK,
                            cmd.value & IOD_HIDE_MASK);
                        break;
                    case IOD_CMD_ACK:
                        switch(cmd.value)
                        {
                        case IOD_EVENT_DEACTIVATED:
                            cs = client_list.cqh_first;
                            DEBUG(printf("Client switched [%i] %i -> [%i] %i\n",
                                pfds[x].fd, find_client(&x, 0)->pid,
                                cs->sock, cs->pid));
                            send_client_status(
                                IOD_EVENT_ACTIVATED, 0, 0);
                            break;
                        case IOD_EVENT_REMOVED:
                            cs = find_client(&x, 0);
                            goto remove;
                        default:
                            DEBUG(printf("Client done [%i] %i\n",
                                pfds[x].fd, find_client(&x, 0)->pid));
                            break;
                        }
                        break;
                    case IOD_CMD_GRAB:
                        cs = find_client(&x, 0);
                        switch(cmd.value & ~IOD_GRAB_MASK)
                        {
                        case IOD_GRAB_AUX:
                            if(!aux_grabber || cs == aux_grabber)
                            {
                                if(cmd.value & IOD_GRAB_MASK)
                                {
                                    DEBUG(printf("AUX grabbed [%i] %i\n",
                                        cs->sock, cs->pid));
                                    aux_grabber = cs;
                                }
                                else
                                {
                                    DEBUG(printf("AUX ungrabbed [%i] %i\n",
                                        cs->sock, cs->pid));
                                    aux_grabber = 0;
                                }
                                send_client_status(IOD_EVENT_GRAB,
                                    IOD_SUCCESS_MASK|IOD_GRAB_AUX, cs);
                            }
                            else
                                send_client_status(IOD_EVENT_GRAB,
                                    IOD_GRAB_AUX, cs);
                            break;
                        case IOD_GRAB_POWER:
                            if(!power_grabber || cs == power_grabber)
                            {
                                if(cmd.value & IOD_GRAB_MASK)
                                {
                                    DEBUG(printf("Power grabbed [%i] %i\n",
                                        cs->sock, cs->pid));
                                    power_grabber = cs;
                                }
                                else
                                {
                                    DEBUG(printf("Power ungrabbed [%i] %i\n",
                                        cs->sock, cs->pid));
                                    power_grabber = 0;
                                }
                                send_client_status(IOD_EVENT_GRAB,
                                    IOD_SUCCESS_MASK|IOD_GRAB_POWER, cs);
                            }
                            else
                                send_client_status(IOD_EVENT_GRAB,
                                    IOD_GRAB_POWER, cs);
                            break;
                        }
                        break;
                    case IOD_CMD_POWERSAVE:
                        DEBUG(printf("Powersave %s broadcast\n",
                            cmd.value ? "on" : "off"));
                        cs = client_list.cqh_first;
                        while(cs != (void*)&client_list)
                        {
                            if(cs->sock != pfds[x].fd)
                                send_client_status(
                                    IOD_EVENT_POWERSAVE, cmd.value, cs);
                            cs = cs->chain.cqe_next;
                        }
                        break;
                    default:
                        DEBUG(printf("Unrecognized command 0x%02hhx [%i] %i\n",
                            cmd.cmd, pfds[x].fd, find_client(&x, 0)->pid));
                    }
                    break;
                }
        }
    }
    
    cleanup();
    
    return 0;
}