Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/* Control socket for client/server test execution
3 *
4 * Copyright (C) 2017 Red Hat, Inc.
5 *
6 * Author: Stefan Hajnoczi <stefanha@redhat.com>
7 */
8
9/* The client and server may need to coordinate to avoid race conditions like
10 * the client attempting to connect to a socket that the server is not
11 * listening on yet. The control socket offers a communications channel for
12 * such coordination tasks.
13 *
14 * If the client calls control_expectln("LISTENING"), then it will block until
15 * the server calls control_writeln("LISTENING"). This provides a simple
16 * mechanism for coordinating between the client and the server.
17 */
18
19#include <errno.h>
20#include <netdb.h>
21#include <stdio.h>
22#include <stdlib.h>
23#include <string.h>
24#include <unistd.h>
25#include <sys/types.h>
26#include <sys/socket.h>
27
28#include "timeout.h"
29#include "control.h"
30#include "util.h"
31
32static int control_fd = -1;
33
34/* Open the control socket, either in server or client mode */
35void control_init(const char *control_host,
36 const char *control_port,
37 bool server)
38{
39 struct addrinfo hints = {
40 .ai_socktype = SOCK_STREAM,
41 };
42 struct addrinfo *result = NULL;
43 struct addrinfo *ai;
44 int ret;
45
46 ret = getaddrinfo(control_host, control_port, &hints, &result);
47 if (ret != 0) {
48 fprintf(stderr, "%s\n", gai_strerror(ret));
49 exit(EXIT_FAILURE);
50 }
51
52 for (ai = result; ai; ai = ai->ai_next) {
53 int fd;
54
55 fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
56 if (fd < 0)
57 continue;
58
59 if (!server) {
60 if (connect(fd, ai->ai_addr, ai->ai_addrlen) < 0)
61 goto next;
62 control_fd = fd;
63 printf("Control socket connected to %s:%s.\n",
64 control_host, control_port);
65 break;
66 }
67
68 setsockopt_int_check(fd, SOL_SOCKET, SO_REUSEADDR, 1,
69 "setsockopt SO_REUSEADDR");
70
71 if (bind(fd, ai->ai_addr, ai->ai_addrlen) < 0)
72 goto next;
73 if (listen(fd, 1) < 0)
74 goto next;
75
76 printf("Control socket listening on %s:%s\n",
77 control_host, control_port);
78 fflush(stdout);
79
80 control_fd = accept(fd, NULL, 0);
81 close(fd);
82
83 if (control_fd < 0) {
84 perror("accept");
85 exit(EXIT_FAILURE);
86 }
87 printf("Control socket connection accepted...\n");
88 break;
89
90next:
91 close(fd);
92 }
93
94 if (control_fd < 0) {
95 fprintf(stderr, "Control socket initialization failed. Invalid address %s:%s?\n",
96 control_host, control_port);
97 exit(EXIT_FAILURE);
98 }
99
100 freeaddrinfo(result);
101}
102
103/* Free resources */
104void control_cleanup(void)
105{
106 close(control_fd);
107 control_fd = -1;
108}
109
110/* Write a line to the control socket */
111void control_writeln(const char *str)
112{
113 ssize_t len = strlen(str);
114 ssize_t ret;
115
116 timeout_begin(TIMEOUT);
117
118 do {
119 ret = send(control_fd, str, len, MSG_MORE);
120 timeout_check("send");
121 } while (ret < 0 && errno == EINTR);
122
123 if (ret != len) {
124 perror("send");
125 exit(EXIT_FAILURE);
126 }
127
128 do {
129 ret = send(control_fd, "\n", 1, 0);
130 timeout_check("send");
131 } while (ret < 0 && errno == EINTR);
132
133 if (ret != 1) {
134 perror("send");
135 exit(EXIT_FAILURE);
136 }
137
138 timeout_end();
139}
140
141void control_writeulong(unsigned long value)
142{
143 char str[32];
144
145 if (snprintf(str, sizeof(str), "%lu", value) >= sizeof(str)) {
146 perror("snprintf");
147 exit(EXIT_FAILURE);
148 }
149
150 control_writeln(str);
151}
152
153unsigned long control_readulong(void)
154{
155 unsigned long value;
156 char *str;
157
158 str = control_readln();
159
160 if (!str)
161 exit(EXIT_FAILURE);
162
163 value = strtoul(str, NULL, 10);
164 free(str);
165
166 return value;
167}
168
169/* Return the next line from the control socket (without the trailing newline).
170 *
171 * The program terminates if a timeout occurs.
172 *
173 * The caller must free() the returned string.
174 */
175char *control_readln(void)
176{
177 char *buf = NULL;
178 size_t idx = 0;
179 size_t buflen = 0;
180
181 timeout_begin(TIMEOUT);
182
183 for (;;) {
184 ssize_t ret;
185
186 if (idx >= buflen) {
187 char *new_buf;
188
189 new_buf = realloc(buf, buflen + 80);
190 if (!new_buf) {
191 perror("realloc");
192 exit(EXIT_FAILURE);
193 }
194
195 buf = new_buf;
196 buflen += 80;
197 }
198
199 do {
200 ret = recv(control_fd, &buf[idx], 1, 0);
201 timeout_check("recv");
202 } while (ret < 0 && errno == EINTR);
203
204 if (ret == 0) {
205 fprintf(stderr, "unexpected EOF on control socket\n");
206 exit(EXIT_FAILURE);
207 }
208
209 if (ret != 1) {
210 perror("recv");
211 exit(EXIT_FAILURE);
212 }
213
214 if (buf[idx] == '\n') {
215 buf[idx] = '\0';
216 break;
217 }
218
219 idx++;
220 }
221
222 timeout_end();
223
224 return buf;
225}
226
227/* Wait until a given line is received or a timeout occurs */
228void control_expectln(const char *str)
229{
230 char *line;
231
232 line = control_readln();
233
234 control_cmpln(line, str, true);
235
236 free(line);
237}
238
239bool control_cmpln(char *line, const char *str, bool fail)
240{
241 if (strcmp(str, line) == 0)
242 return true;
243
244 if (fail) {
245 fprintf(stderr, "expected \"%s\" on control socket, got \"%s\"\n",
246 str, line);
247 exit(EXIT_FAILURE);
248 }
249
250 return false;
251}
1/* Control socket for client/server test execution
2 *
3 * Copyright (C) 2017 Red Hat, Inc.
4 *
5 * Author: Stefan Hajnoczi <stefanha@redhat.com>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; version 2
10 * of the License.
11 */
12
13/* The client and server may need to coordinate to avoid race conditions like
14 * the client attempting to connect to a socket that the server is not
15 * listening on yet. The control socket offers a communications channel for
16 * such coordination tasks.
17 *
18 * If the client calls control_expectln("LISTENING"), then it will block until
19 * the server calls control_writeln("LISTENING"). This provides a simple
20 * mechanism for coordinating between the client and the server.
21 */
22
23#include <errno.h>
24#include <netdb.h>
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include <unistd.h>
29#include <sys/types.h>
30#include <sys/socket.h>
31
32#include "timeout.h"
33#include "control.h"
34
35static int control_fd = -1;
36
37/* Open the control socket, either in server or client mode */
38void control_init(const char *control_host,
39 const char *control_port,
40 bool server)
41{
42 struct addrinfo hints = {
43 .ai_socktype = SOCK_STREAM,
44 };
45 struct addrinfo *result = NULL;
46 struct addrinfo *ai;
47 int ret;
48
49 ret = getaddrinfo(control_host, control_port, &hints, &result);
50 if (ret != 0) {
51 fprintf(stderr, "%s\n", gai_strerror(ret));
52 exit(EXIT_FAILURE);
53 }
54
55 for (ai = result; ai; ai = ai->ai_next) {
56 int fd;
57 int val = 1;
58
59 fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
60 if (fd < 0)
61 continue;
62
63 if (!server) {
64 if (connect(fd, ai->ai_addr, ai->ai_addrlen) < 0)
65 goto next;
66 control_fd = fd;
67 printf("Control socket connected to %s:%s.\n",
68 control_host, control_port);
69 break;
70 }
71
72 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
73 &val, sizeof(val)) < 0) {
74 perror("setsockopt");
75 exit(EXIT_FAILURE);
76 }
77
78 if (bind(fd, ai->ai_addr, ai->ai_addrlen) < 0)
79 goto next;
80 if (listen(fd, 1) < 0)
81 goto next;
82
83 printf("Control socket listening on %s:%s\n",
84 control_host, control_port);
85 fflush(stdout);
86
87 control_fd = accept(fd, NULL, 0);
88 close(fd);
89
90 if (control_fd < 0) {
91 perror("accept");
92 exit(EXIT_FAILURE);
93 }
94 printf("Control socket connection accepted...\n");
95 break;
96
97next:
98 close(fd);
99 }
100
101 if (control_fd < 0) {
102 fprintf(stderr, "Control socket initialization failed. Invalid address %s:%s?\n",
103 control_host, control_port);
104 exit(EXIT_FAILURE);
105 }
106
107 freeaddrinfo(result);
108}
109
110/* Free resources */
111void control_cleanup(void)
112{
113 close(control_fd);
114 control_fd = -1;
115}
116
117/* Write a line to the control socket */
118void control_writeln(const char *str)
119{
120 ssize_t len = strlen(str);
121 ssize_t ret;
122
123 timeout_begin(TIMEOUT);
124
125 do {
126 ret = send(control_fd, str, len, MSG_MORE);
127 timeout_check("send");
128 } while (ret < 0 && errno == EINTR);
129
130 if (ret != len) {
131 perror("send");
132 exit(EXIT_FAILURE);
133 }
134
135 do {
136 ret = send(control_fd, "\n", 1, 0);
137 timeout_check("send");
138 } while (ret < 0 && errno == EINTR);
139
140 if (ret != 1) {
141 perror("send");
142 exit(EXIT_FAILURE);
143 }
144
145 timeout_end();
146}
147
148/* Return the next line from the control socket (without the trailing newline).
149 *
150 * The program terminates if a timeout occurs.
151 *
152 * The caller must free() the returned string.
153 */
154char *control_readln(void)
155{
156 char *buf = NULL;
157 size_t idx = 0;
158 size_t buflen = 0;
159
160 timeout_begin(TIMEOUT);
161
162 for (;;) {
163 ssize_t ret;
164
165 if (idx >= buflen) {
166 char *new_buf;
167
168 new_buf = realloc(buf, buflen + 80);
169 if (!new_buf) {
170 perror("realloc");
171 exit(EXIT_FAILURE);
172 }
173
174 buf = new_buf;
175 buflen += 80;
176 }
177
178 do {
179 ret = recv(control_fd, &buf[idx], 1, 0);
180 timeout_check("recv");
181 } while (ret < 0 && errno == EINTR);
182
183 if (ret == 0) {
184 fprintf(stderr, "unexpected EOF on control socket\n");
185 exit(EXIT_FAILURE);
186 }
187
188 if (ret != 1) {
189 perror("recv");
190 exit(EXIT_FAILURE);
191 }
192
193 if (buf[idx] == '\n') {
194 buf[idx] = '\0';
195 break;
196 }
197
198 idx++;
199 }
200
201 timeout_end();
202
203 return buf;
204}
205
206/* Wait until a given line is received or a timeout occurs */
207void control_expectln(const char *str)
208{
209 char *line;
210
211 line = control_readln();
212 if (strcmp(str, line) != 0) {
213 fprintf(stderr, "expected \"%s\" on control socket, got \"%s\"\n",
214 str, line);
215 exit(EXIT_FAILURE);
216 }
217
218 free(line);
219}