-WARNS6 cleanup (229 warnings)
[dragonfly.git] / bin / cpdup / hclink.c
1 /*
2  * HCLINK.C
3  *
4  * This module implements a simple remote control protocol
5  *
6  * $DragonFly: src/bin/cpdup/hclink.c,v 1.3 2006/08/18 01:13:51 dillon Exp $
7  */
8
9 #include <sys/types.h>
10 #include <sys/stat.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <unistd.h>
14 #include <string.h>
15 #include <fcntl.h>
16 #include <dirent.h>
17 #include <assert.h>
18 #include <errno.h>
19
20 #include "hclink.h"
21 #include "hcproto.h"
22
23 static struct HCHead *hcc_read_command(struct HostConf *hc);
24
25 int
26 hcc_connect(struct HostConf *hc)
27 {
28     int fdin[2];
29     int fdout[2];
30
31     if (hc == NULL || hc->host == NULL)
32         return(0);
33
34     if (pipe(fdin) < 0)
35         return(-1);
36     if (pipe(fdout) < 0) {
37         close(fdin[0]);
38         close(fdin[1]);
39         return(-1);
40     }
41     if ((hc->pid = fork()) == 0) {
42         /*
43          * Child process
44          */
45         dup2(fdin[1], 1);
46         close(fdin[0]);
47         close(fdin[1]);
48         dup2(fdout[0], 0);
49         close(fdout[0]);
50         close(fdout[1]);
51         execl("/usr/bin/ssh", "ssh", "-T", hc->host, "cpdup", "-S", NULL);
52         _exit(1);
53     } else if (hc->pid < 0) {
54         return(-1);
55     } else {
56         /*
57          * Parent process.  Do the initial handshake to make sure we are
58          * actually talking to a cpdup slave.
59          */
60         close(fdin[1]);
61         hc->fdin = fdin[0];
62         close(fdout[0]);
63         hc->fdout = fdout[1];
64         return(0);
65     }
66 }
67
68 static int
69 rc_badop(struct HostConf *hc __unused, struct HCHead *head)
70 {
71     head->error = EOPNOTSUPP;
72     return(0);
73 }
74
75 int
76 hcc_slave(int fdin, int fdout, struct HCDesc *descs, int count)
77 {
78     struct HostConf hcslave;
79     struct HCHead *head;
80     struct HCHead *whead;
81     int (*dispatch[256])(struct HostConf *, struct HCHead *);
82     int aligned_bytes;
83     int i;
84     int r;
85
86     bzero(&hcslave, sizeof(hcslave));
87     for (i = 0; i < count; ++i) {
88         struct HCDesc *desc = &descs[i];
89         assert(desc->cmd >= 0 && desc->cmd < 256);
90         dispatch[desc->cmd] = desc->func;
91     }
92     for (i = 0; i < 256; ++i) {
93         if (dispatch[i] == NULL)
94             dispatch[i] = rc_badop;
95     }
96     hcslave.fdin = fdin;
97     hcslave.fdout = fdout;
98
99     /*
100      * Process commands on fdin and write out results on fdout
101      */
102     for (;;) {
103         /*
104          * Get the command
105          */
106         head = hcc_read_command(&hcslave);
107         if (head == NULL)
108             break;
109
110         /*
111          * Start the reply and dispatch, then process the return code.
112          */
113         head->error = 0;
114         hcc_start_command(&hcslave, head->cmd | HCF_REPLY);
115         r = dispatch[head->cmd & 255](&hcslave, head);
116         switch(r) {
117         case -2:
118                 head->error = EINVAL;
119                 break;
120         case -1:
121                 head->error = errno;
122                 break;
123         case 0:
124                 break;
125         default:
126                 assert(0);
127                 break;
128         }
129
130         /*
131          * Write out the reply
132          */
133         whead = (void *)hcslave.wbuf;
134         whead->bytes = hcslave.windex;
135         whead->error = head->error;
136         aligned_bytes = HCC_ALIGN(hcslave.windex);
137 #ifdef DEBUG
138         hcc_debug_dump(whead);
139 #endif
140         if (write(hcslave.fdout, whead, aligned_bytes) != aligned_bytes)
141             break;
142     }
143     return(0);
144 }
145
146 /*
147  * This reads a command from fdin, fixes up the byte ordering, and returns
148  * a pointer to HCHead.
149  */
150 static
151 struct HCHead *
152 hcc_read_command(struct HostConf *hc)
153 {
154     struct HCHead *head;
155     int aligned_bytes;
156     int n;
157     int r;
158
159     n = 0;
160     while (n < (int)sizeof(struct HCHead)) {
161         r = read(hc->fdin, hc->rbuf + n, sizeof(struct HCHead) - n);
162         if (r <= 0)
163             return(NULL);
164         n += r;
165     }
166     head = (void *)hc->rbuf;
167     assert(head->bytes >= (int)sizeof(*head) && head->bytes < 65536);
168     assert(head->magic == HCMAGIC);
169     aligned_bytes = HCC_ALIGN(head->bytes);
170     while (n < aligned_bytes) {
171         r = read(hc->fdin, hc->rbuf + n, aligned_bytes - n);
172         if (r <= 0)
173             return(NULL);
174         n += r;
175     }
176 #ifdef DEBUG
177     hcc_debug_dump(head);
178 #endif
179     return(head);
180 }
181
182 /*
183  * Initialize for a new command
184  */
185 void
186 hcc_start_command(struct HostConf *hc, int16_t cmd)
187 {
188     struct HCHead *whead = (void *)hc->wbuf;
189
190     whead->magic = HCMAGIC;
191     whead->bytes = 0;
192     whead->cmd = cmd;
193     whead->id = 0;
194     whead->error = 0;
195     hc->windex = sizeof(*whead);
196 }
197
198 /*
199  * Finish constructing a command, transmit it, and await the reply.
200  * Return the HCHead of the reply.
201  */
202 struct HCHead *
203 hcc_finish_command(struct HostConf *hc)
204 {
205     struct HCHead *whead;
206     struct HCHead *rhead;
207     int aligned_bytes;
208
209     whead = (void *)hc->wbuf;
210     whead->bytes = hc->windex;
211     aligned_bytes = HCC_ALIGN(hc->windex);
212     if (write(hc->fdout, whead, aligned_bytes) != aligned_bytes) {
213 #ifdef __error
214         *__error = EIO;
215 #else
216         errno = EIO;
217 #endif
218         if (whead->cmd < 0x0010)
219                 return(NULL);
220         fprintf(stderr, "cpdup lost connection to %s\n", hc->host);
221         exit(1);
222     }
223     if ((rhead = hcc_read_command(hc)) == NULL) {
224 #ifdef __error
225         *__error = EIO;
226 #else
227         errno = EIO;
228 #endif
229         if (whead->cmd < 0x0010)
230                 return(NULL);
231         fprintf(stderr, "cpdup lost connection to %s\n", hc->host);
232         exit(1);
233     }
234     if (rhead->error) {
235 #ifdef __error
236         *__error = rhead->error;
237 #else
238         errno = rhead->error;
239 #endif
240     }
241     return (rhead);
242 }
243
244 void
245 hcc_leaf_string(struct HostConf *hc, int16_t leafid, const char *str)
246 {
247     struct HCLeaf *item;
248     int bytes = strlen(str) + 1;
249
250     item = (void *)(hc->wbuf + hc->windex);
251     assert(hc->windex + sizeof(*item) + bytes < 65536);
252     item->leafid = leafid;
253     item->reserved = 0;
254     item->bytes = sizeof(*item) + bytes;
255     bcopy(str, item + 1, bytes);
256     hc->windex = HCC_ALIGN(hc->windex + item->bytes);
257 }
258
259 void
260 hcc_leaf_data(struct HostConf *hc, int16_t leafid, const void *ptr, int bytes)
261 {
262     struct HCLeaf *item;
263
264     item = (void *)(hc->wbuf + hc->windex);
265     assert(hc->windex + sizeof(*item) + bytes < 65536);
266     item->leafid = leafid;
267     item->reserved = 0;
268     item->bytes = sizeof(*item) + bytes;
269     bcopy(ptr, item + 1, bytes);
270     hc->windex = HCC_ALIGN(hc->windex + item->bytes);
271 }
272
273 void
274 hcc_leaf_int32(struct HostConf *hc, int16_t leafid, int32_t value)
275 {
276     struct HCLeaf *item;
277
278     item = (void *)(hc->wbuf + hc->windex);
279     assert(hc->windex + sizeof(*item) + sizeof(value) < 65536);
280     item->leafid = leafid;
281     item->reserved = 0;
282     item->bytes = sizeof(*item) + sizeof(value);
283     *(int32_t *)(item + 1) = value;
284     hc->windex = HCC_ALIGN(hc->windex + item->bytes);
285 }
286
287 void
288 hcc_leaf_int64(struct HostConf *hc, int16_t leafid, int64_t value)
289 {
290     struct HCLeaf *item;
291
292     item = (void *)(hc->wbuf + hc->windex);
293     assert(hc->windex + sizeof(*item) + sizeof(value) < 65536);
294     item->leafid = leafid;
295     item->reserved = 0;
296     item->bytes = sizeof(*item) + sizeof(value);
297     *(int64_t *)(item + 1) = value;
298     hc->windex = HCC_ALIGN(hc->windex + item->bytes);
299 }
300
301 int
302 hcc_alloc_descriptor(struct HostConf *hc, void *ptr, int type)
303 {
304     struct HCHostDesc *hd;
305     struct HCHostDesc *hnew;
306
307     hnew = malloc(sizeof(struct HCHostDesc));
308     hnew->type = type;
309     hnew->data = ptr;
310
311     if ((hd = hc->hostdescs) != NULL) {
312         hnew->desc = hd->desc + 1;
313     } else {
314         hnew->desc = 1;
315     }
316     hnew->next = hd;
317     hc->hostdescs = hnew;
318     return(hnew->desc);
319 }
320
321 void *
322 hcc_get_descriptor(struct HostConf *hc, int desc, int type)
323 {
324     struct HCHostDesc *hd;
325
326     for (hd = hc->hostdescs; hd; hd = hd->next) {
327         if (hd->desc == desc && hd->type == type)
328             return(hd->data);
329     }
330     return(NULL);
331 }
332
333 void
334 hcc_set_descriptor(struct HostConf *hc, int desc, void *ptr, int type)
335 {
336     struct HCHostDesc *hd;
337     struct HCHostDesc **hdp;
338
339     for (hdp = &hc->hostdescs; (hd = *hdp) != NULL; hdp = &hd->next) {
340         if (hd->desc == desc) {
341             if (ptr) {
342                 hd->data = ptr;
343                 hd->type = type;
344             } else {
345                 *hdp = hd->next;
346                 free(hd);
347             }
348             return;
349         }
350     }
351     if (ptr) {
352         hd = malloc(sizeof(*hd));
353         hd->desc = desc;
354         hd->type = type;
355         hd->data = ptr;
356         hd->next = hc->hostdescs;
357         hc->hostdescs = hd;
358     }
359 }
360
361 struct HCLeaf *
362 hcc_firstitem(struct HCHead *head)
363 {
364     struct HCLeaf *item;
365     int offset;
366
367     offset = sizeof(*head);
368     if (offset == head->bytes)
369         return(NULL);
370     assert(head->bytes >= offset + (int)sizeof(*item));
371     item = (void *)(head + 1);
372     assert(head->bytes >= offset + item->bytes);
373     assert(item->bytes >= (int)sizeof(*item) && item->bytes < 65536 - offset);
374     return (item);
375 }
376
377 struct HCLeaf *
378 hcc_nextitem(struct HCHead *head, struct HCLeaf *item)
379 {
380     int offset;
381
382     item = (void *)((char *)item + HCC_ALIGN(item->bytes));
383     offset = (char *)item - (char *)head;
384     if (offset == head->bytes)
385         return(NULL);
386     assert(head->bytes >= offset + (int)sizeof(*item));
387     assert(head->bytes >= offset + item->bytes);
388     assert(item->bytes >= (int)sizeof(*item) && item->bytes < 65536 - offset);
389     return (item);
390 }
391
392 #ifdef DEBUG
393
394 void
395 hcc_debug_dump(struct HCHead *head)
396 {
397     struct HCLeaf *item;
398     int aligned_bytes = HCC_ALIGN(head->bytes);
399
400     fprintf(stderr, "DUMP %04x (%d)", (u_int16_t)head->cmd, aligned_bytes);
401     if (head->cmd & HCF_REPLY)
402         fprintf(stderr, " error %d", head->error);
403     fprintf(stderr, "\n");
404     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
405         fprintf(stderr, "    ITEM %04x DATA ", item->leafid);
406         switch(item->leafid & LCF_TYPEMASK) {
407         case LCF_INT32:
408             fprintf(stderr, "int32 %d\n", *(int32_t *)(item + 1));
409             break;
410         case LCF_INT64:
411             fprintf(stderr, "int64 %lld\n", *(int64_t *)(item + 1));
412             break;
413         case LCF_STRING:
414             fprintf(stderr, "\"%s\"\n", (char *)(item + 1));
415             break;
416         case LCF_BINARY:
417             fprintf(stderr, "(binary)\n");
418             break;
419         default:
420             printf("?\n");
421         }
422     }
423 }
424
425 #endif