cgex/cgexd-cli.c at main · nine7nine/cgex · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#include "libcgex.h"

int main(int argc, char *argv[]) {
    const char *cg_group = NULL;
    const char *cg_opt = NULL;
    const char *cg_attr = NULL;
    const char *cg_type = NULL;

    int opt, r_flag = 0, s_flag = 0, t_flag = 0;

    // Initialize command buffer
    char *cmd = malloc(MAX_COMMAND_LENGTH);
    if (cmd == NULL) {
        fprintf(stderr, "Error: Memory allocation failed\n");
        return EXIT_FAILURE;
    }
    cmd[0] = '\0';

    // Initialize response buffer
    char *response = malloc(BUF_SIZE);
    if (response == NULL) {
        fprintf(stderr, "Error: Memory allocation failed\n");
        free(cmd);
        return EXIT_FAILURE;
    }
    response[0] = '\0';

    while ((opt = getopt(argc, argv, "g:r:s:t:")) != -1) {
        switch (opt) {
            case 'g':
                cg_group = optarg;
                break;
            case 'r':
                if (s_flag || t_flag) {
                    fprintf(stderr, "%s", ERROR_RS_TOGETHER);
                    clr_exit(cmd, response, -1);
                }
                cg_opt = optarg;
                r_flag = 1;
                break;
            case 's':
                if (r_flag || t_flag) {
                    fprintf(stderr, "%s", ERROR_RS_TOGETHER);
                    clr_exit(cmd, response, -1);
                }
                cg_attr = optarg;
                s_flag = 1;
                break;
            case 't':
                if (r_flag || s_flag) {
                    fprintf(stderr, "%s", ERROR_RS_TOGETHER);
                    clr_exit(cmd, response, -1);
                }
                cg_type = optarg;
                t_flag = 1;
                break;
            default:
                fprintf(stderr, ERROR_USAGE, argv[0]);
                clr_exit(cmd, response, -1);
        }
    }

    if (cg_group == NULL) {
        fprintf(stderr, "%s", ERROR_MISSING_CG_GROUP);
        clr_exit(cmd, response, -1);
    }

    // Construct command
    concat_str(&cmd, "-g ");
    concat_str(&cmd, cg_group);
    if (r_flag) {
        concat_str(&cmd, " -r");
        if (strcmp(cg_opt, "all") == 0) {
            concat_str(&cmd, " all");
        } else {
            concat_str(&cmd, " ");
            concat_str(&cmd, cg_opt);
        }
    } else if (s_flag) {
        if (optind >= argc) {
            fprintf(stderr, "%s", ERROR_MISSING_ARG);
            clr_exit(cmd, response, -1);
        }
        concat_str(&cmd, " -s ");
        concat_str(&cmd, cg_attr);
        concat_str(&cmd, " ");
        concat_str(&cmd, argv[optind]);
    } else if (t_flag) {
        concat_str(&cmd, " -t ");
        concat_str(&cmd, cg_type);
    }

    // Connect to the daemon
    int sockfd = sockt_srv_connect(DAEMON_SOCKET_PATH);
    if (sockfd < 0) {
        // Handle connection error
        exit(EXIT_FAILURE);
    }

    // Send command to daemon
    printf("Sending command to daemon: %s\n", cmd);
    sockt_send(sockfd, cmd, strlen(cmd));

    // Receive and print response from daemon
    ssize_t bytes_received;
    while ((bytes_received = sockt_recv(sockfd, response, BUF_SIZE - 1)) > 0) {
        response[bytes_received] = '\0';
        printf("%s", response);
    }

    if (bytes_received < 0) {
        fprintf(stderr, "Error: Failed to receive response from daemon\n");
        clr_exit(cmd, response, sockfd);
    }

    free(cmd);
    free(response);
    sockt_close(sockfd);

    return EXIT_SUCCESS;
}