3 * Copyright (c) 2004 Scott Ullrich <GeekGod@GeekGod.com>
4 * Portions Copyright (c) 2004 Chris Pressey <cpressey@catseye.mine.nu>
6 * Copyright (c) 2004 The DragonFly Project.
9 * This code is derived from software contributed to The DragonFly Project
10 * by Scott Ullrich and Chris Pressey (see above for e-mail addresses).
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
19 * 2. Redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in
21 * the documentation and/or other materials provided with the
24 * 3. Neither the name of The DragonFly Project nor the names of its
25 * contributors may be used to endorse or promote products derived
26 * from this software without specific, prior written permission.
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
31 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
32 * COPYRIGHT HOLDERS, CONTRIBUTORS OR VOICES IN THE AUTHOR'S HEAD
33 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY
34 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
35 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
36 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
37 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
38 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
39 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
41 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
42 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
43 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
44 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
45 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
46 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52 * $Id: conn_tcp.c,v 1.16 2005/02/06 19:53:19 cpressey Exp $
58 #include <sys/types.h>
61 #include <sys/errno.h>
62 #include <sys/types.h>
63 #include <sys/socket.h>
64 #include <netinet/in.h>
65 #include <arpa/inet.h>
75 #include <libaura/buffer.h>
77 #define NEEDS_DFUI_STRUCTURE_DEFINITIONS
79 #undef NEEDS_DFUI_STRUCTURE_DEFINITIONS
84 /***** BACKEND ******/
89 * Connect to the frontend.
92 dfui_tcp_be_start(struct dfui_connection *c)
94 struct sockaddr_in servaddr;
98 server_port = atoi(c->rendezvous);
101 * Create the tcp socket
104 if ((T_TCP(c)->listen_sd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
105 return(DFUI_FAILURE);
106 dfui_debug("LISTEN_SOCKET<<%d>>\n", T_TCP(c)->listen_sd);
108 if (setsockopt(T_TCP(c)->listen_sd, SOL_SOCKET, SO_REUSEADDR,
109 &tru, sizeof(tru)) == -1) {
110 return(DFUI_FAILURE);
113 bzero(&servaddr, sizeof(servaddr));
114 servaddr.sin_family = AF_INET;
115 servaddr.sin_port = htons(server_port);
116 switch(inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr)) {
118 warnx("inet_pton(): address not parseable");
119 return(DFUI_FAILURE);
124 return(DFUI_FAILURE);
127 if (bind(T_TCP(c)->listen_sd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
129 return(DFUI_FAILURE);
131 dfui_debug("BOUND_ON<<%d>>\n", T_TCP(c)->listen_sd);
132 if (listen(T_TCP(c)->listen_sd, 0) == -1)
133 return(DFUI_FAILURE);
134 dfui_debug("LISTENING_ON<<%d>>\n", T_TCP(c)->listen_sd);
135 /* at this point we should be listening on the rendezvous port */
136 return(DFUI_SUCCESS);
140 * Tell the frontend that we're done and disconnect from it.
143 dfui_tcp_be_stop(struct dfui_connection *c)
145 if (dfui_tcp_be_ll_exchange(c, DFUI_BE_MSG_STOP, "")) {
146 close(T_TCP(c)->listen_sd);
147 close(T_TCP(c)->connected_sd);
148 fclose(T_TCP(c)->stream);
149 return(DFUI_SUCCESS);
151 return(DFUI_FAILURE);
157 * Exchange a message with the frontend. This involves two receive()/reply()
158 * cycles: one to provide our message, one to get a reply from the frontend.
160 * Note that this does not immediately send the message to the frontend -
161 * it can't, because we're a service and it's a client. What it does is
162 * keep the message handy and wait for a frontend request to come in. It
163 * then replies to that request with our message.
165 * The protocol looks something like the following, using the PRESENT and
166 * SUBMIT exchange as an example:
168 * frontend (client) | backend (service)
169 * ------------------+------------------
172 * READY --> ll_receive()
173 * <-- PRESENT(form) ll_reply()
176 * SUBMIT(form) --> ll_receive()
177 * <-- READY ll_reply()
179 * Each of those exchanges is a pair of calls, on our end, to
180 * dfui_tcp_be_ll_receive() and dfui_npipe_be_ll_reply().
182 * The set of messages that the client can pass us is determined by
183 * the conversation state:
185 * o In stage 1, only READY and ABORT are meaningful.
186 * o After a PRESENT, the messages SUBMIT and ABORT are meaningul
188 * o During a PROG_*, the messages CONTINUE, CANCEL, and ABORT
189 * are meaningful in stage 2.
191 * If the frontend sends us with READY in stage 2, we assume it has
192 * fallen out of sync, so we send the same initial reply again, going
193 * back to stage 1 as it were.
195 * After this call, the message is available in c->ebuf.
198 dfui_tcp_be_ll_exchange(struct dfui_connection *c, char msgtype, const char *msg)
203 * Construct our message to send.
206 fmsg = malloc(strlen(msg) + 2);
208 strcpy(fmsg + 1, msg);
211 * Get the frontend's message.
214 dfui_tcp_be_ll_receive(c);
217 * Frontend message should have been either READY or ABORT.
218 * If ABORT, we get out of here pronto.
221 if (aura_buffer_buf(c->ebuf)[0] == DFUI_FE_MSG_ABORT) {
223 return(DFUI_FAILURE);
226 /* XXX if (!READY) ??? */
229 dfui_tcp_be_ll_reply(c, fmsg);
232 * Here, the frontend has picked up our request and is
233 * processing it. We have to wait for the response.
236 dfui_tcp_be_ll_receive(c);
239 * Did we get READY from this?
243 } while (aura_buffer_buf(c->ebuf)[0] == DFUI_FE_MSG_READY);
245 fmsg[0] = DFUI_BE_MSG_READY;
247 dfui_tcp_be_ll_reply(c, fmsg);
250 return(DFUI_SUCCESS);
254 * Receive a message from the frontend.
255 * This call is synchronous.
256 * After this call, the NUL-terminated message is available in
260 dfui_tcp_be_ll_receive(struct dfui_connection *c)
267 if (!T_TCP(c)->is_connected) {
268 dfui_debug("NOT_CONNECTED,ACCEPTING_ON<<%d>>\n", T_TCP(c)->listen_sd);
269 T_TCP(c)->connected_sd = accept(T_TCP(c)->listen_sd, NULL, NULL);
270 dfui_debug("ACCEPTED<<%d>>\n", T_TCP(c)->connected_sd);
271 T_TCP(c)->stream = fdopen(T_TCP(c)->connected_sd, "r+");
272 T_TCP(c)->is_connected = 1;
274 dfui_debug("ALREADY_CONNECTED<<>>\n");
277 dfui_debug("WAITING<<>>\n");
279 if (read_data(T_TCP(c)->stream, (char *)&length, sizeof(length)) == -1) {
280 dfui_debug("LOST_THEM<<>>\n");
281 fclose(T_TCP(c)->stream);
282 T_TCP(c)->is_connected = 0;
286 buf = malloc(length + 1);
287 if (read_data(T_TCP(c)->stream, buf, length) == -1) {
288 dfui_debug("LOST_THEM<<>>\n");
289 fclose(T_TCP(c)->stream);
290 T_TCP(c)->is_connected = 0;
294 aura_buffer_set(c->ebuf, buf, length);
297 dfui_debug("RECEIVED<<%s>>\n", aura_buffer_buf(c->ebuf));
299 return(DFUI_SUCCESS);
303 * Send a NUL-terminated reply to the frontend.
306 dfui_tcp_be_ll_reply(struct dfui_connection *c, const char *fmsg)
310 dfui_debug("SEND<<%s>>\n", fmsg);
311 length = strlen(fmsg);
312 write_data(T_TCP(c)->stream, (char *)&length, sizeof(length));
313 write_data(T_TCP(c)->stream, fmsg, length);
315 return(DFUI_SUCCESS);
318 /******** FRONTEND ********/
323 dfui_tcp_fe_connect(struct dfui_connection *c)
325 struct sockaddr_in servaddr;
329 server_port = atoi(c->rendezvous);
332 * Create the tcp socket
336 if ((T_TCP(c)->connected_sd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
337 return(DFUI_FAILURE);
340 dfui_debug("CLIENT_SOCKET<<%d>>\n", T_TCP(c)->connected_sd);
341 bzero(&servaddr, sizeof(servaddr));
342 servaddr.sin_family = AF_INET;
343 servaddr.sin_port = htons(server_port);
344 inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
346 if (connect(T_TCP(c)->connected_sd, (struct sockaddr *)&servaddr,
347 sizeof(servaddr)) == 0) {
348 dfui_debug("CONNECTED<<>>\n");
351 dfui_debug("NO_CONNECT<<>>\n");
352 close(T_TCP(c)->connected_sd);
357 /* at this point we should be connected */
359 T_TCP(c)->stream = fdopen(T_TCP(c)->connected_sd, "r+");
361 return(DFUI_SUCCESS);
365 dfui_tcp_fe_disconnect(struct dfui_connection *c)
367 close(T_TCP(c)->connected_sd);
368 return(DFUI_SUCCESS);
374 * Ask for, and subsequently receieve, a message from the backend.
375 * msgtype should be one of the DFUI_FE_MSG_* constants.
376 * This call is synchronous.
377 * After this call, the null-terminated, encoded message is
378 * available in T_TCP(c)->buf.
381 dfui_tcp_fe_ll_request(struct dfui_connection *c, char msgtype, const char *msg)
387 * First, assert that the connection is open.
390 if (c == NULL || T_TCP(c)->connected_sd == -1)
391 return(DFUI_FAILURE);
394 * Construct a message.
397 fmsg = malloc(strlen(msg) + 2);
399 strcpy(fmsg + 1, msg);
400 dfui_debug("SEND<<%s>>\n", fmsg);
403 * Send a NUL-terminated message to the backend.
406 length = strlen(fmsg);
407 result = write_data(T_TCP(c)->stream, (char *)&length, sizeof(length));
408 dfui_debug("result<<%d>>\n", result);
409 result = write_data(T_TCP(c)->stream, (char *)fmsg, length);
410 dfui_debug("result<<%d>>\n", result);
413 * Receive a reply from the backend.
414 * If our message was a READY, this should be a message like PRESENT.
415 * Otherwise it should simply be a READY.
418 dfui_debug("WAITING<<>>\n");
419 result = read_data(T_TCP(c)->stream, (char *)&length, sizeof(length));
420 dfui_debug("result<<%d>>\n", result);
421 buf = malloc(length + 1);
422 result = read_data(T_TCP(c)->stream, buf, length);
423 dfui_debug("result<<%d>>\n", result);
424 aura_buffer_set(c->ebuf, buf, length);
427 dfui_debug("RECV<<%s>>\n", aura_buffer_buf(c->ebuf));
431 return(DFUI_SUCCESS);
435 read_data(FILE *f, char *buf, int n)
437 int bcount; /* counts bytes read */
438 int br; /* bytes read this pass */
443 if ((br = fread(buf, 1, n - bcount, f)) > 0) {
444 dfui_debug("READ_BYTES<<%d>>\n", br);
447 } else if (br <= 0) {
448 dfui_debug("read_data_error<<%d>>\n", br);
456 write_data(FILE *f, const char *buf, int n)
458 int bcount; /* counts bytes written */
459 int bw; /* bytes written this pass */
464 if ((bw = fwrite(buf, 1, n - bcount, f)) > 0) {
465 dfui_debug("WROTE_BYTES<<%d>>\n", bw);
468 } else if (bw <= 0) {
469 dfui_debug("write_data_error<<%d>>\n", bw);