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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
/*
SSSD
SSS Client Responder, command parser
Copyright (C) Simo Sorce <ssorce@redhat.com> 2008
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <errno.h>
#include "util/util.h"
#include "responder/common/responder.h"
#include "responder/common/responder_packet.h"
int sss_cmd_empty_packet(struct sss_packet *packet)
{
uint8_t *body;
size_t blen;
int ret;
ret = sss_packet_grow(packet, 2*sizeof(uint32_t));
if (ret != EOK) return ret;
sss_packet_get_body(packet, &body, &blen);
((uint32_t *)body)[0] = 0; /* num results */
((uint32_t *)body)[1] = 0; /* reserved */
return EOK;
}
int sss_cmd_send_empty(struct cli_ctx *cctx, TALLOC_CTX *freectx)
{
int ret;
/* create response packet */
ret = sss_packet_new(cctx->creq, 0,
sss_packet_get_cmd(cctx->creq->in),
&cctx->creq->out);
if (ret != EOK) {
return ret;
}
ret = sss_cmd_empty_packet(cctx->creq->out);
if (ret != EOK) {
return ret;
}
sss_packet_set_error(cctx->creq->out, EOK);
sss_cmd_done(cctx, freectx);
return EOK;
}
void sss_cmd_done(struct cli_ctx *cctx, void *freectx)
{
/* now that the packet is in place, unlock queue
* making the event writable */
TEVENT_FD_WRITEABLE(cctx->cfde);
/* free all request related data through the talloc hierarchy */
talloc_free(freectx);
}
int sss_cmd_get_version(struct cli_ctx *cctx)
{
uint8_t *req_body;
size_t req_blen;
uint8_t *body;
size_t blen;
int ret;
uint32_t client_version;
int i;
static struct cli_protocol_version *cli_protocol_version = NULL;
cctx->cli_protocol_version = NULL;
if (cli_protocol_version == NULL) {
cli_protocol_version = register_cli_protocol_version();
}
if (cli_protocol_version != NULL) {
cctx->cli_protocol_version = &cli_protocol_version[0];
sss_packet_get_body(cctx->creq->in, &req_body, &req_blen);
if (req_blen == sizeof(uint32_t)) {
memcpy(&client_version, req_body, sizeof(uint32_t));
DEBUG(5, ("Received client version [%d].\n", client_version));
i=0;
while(cli_protocol_version[i].version>0) {
if (cli_protocol_version[i].version == client_version) {
cctx->cli_protocol_version = &cli_protocol_version[i];
break;
}
i++;
}
}
}
/* create response packet */
ret = sss_packet_new(cctx->creq, sizeof(uint32_t),
sss_packet_get_cmd(cctx->creq->in),
&cctx->creq->out);
if (ret != EOK) {
return ret;
}
sss_packet_get_body(cctx->creq->out, &body, &blen);
((uint32_t *)body)[0] = cctx->cli_protocol_version!=NULL ?
cctx->cli_protocol_version->version : 0;
DEBUG(5, ("Offered version [%d].\n", ((uint32_t *)body)[0]));
sss_cmd_done(cctx, NULL);
return EOK;
}
int sss_cmd_execute(struct cli_ctx *cctx, struct sss_cmd_table *sss_cmds)
{
enum sss_cli_command cmd;
int i;
cmd = sss_packet_get_cmd(cctx->creq->in);
for (i = 0; sss_cmds[i].cmd != SSS_CLI_NULL; i++) {
if (cmd == sss_cmds[i].cmd) {
return sss_cmds[i].fn(cctx);
}
}
return EINVAL;
}
|
