?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Testing - fix bugs in fsx related to 64-bit systems.
[dragonfly.git] / usr.sbin / atm / scspd / scsp_output.c
blobaeddbc0c98318f405be2fea602956d198ef5214b
1 /*
2 *
3 * ===================================
4 * HARP | Host ATM Research Platform
5 * ===================================
6 *
7 *
8 * This Host ATM Research Platform ("HARP") file (the "Software") is
9 * made available by Network Computing Services, Inc. ("NetworkCS")
10 * "AS IS". NetworkCS does not provide maintenance, improvements or
11 * support of any kind.
12 *
13 * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
14 * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
15 * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
16 * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
17 * In no event shall NetworkCS be responsible for any damages, including
18 * but not limited to consequential damages, arising from or relating to
19 * any use of the Software or related support.
20 *
21 * Copyright 1994-1998 Network Computing Services, Inc.
22 *
23 * Copies of this Software may be made, however, the above copyright
24 * notice must be reproduced on all copies.
25 *
26 * @(#) $FreeBSD: src/usr.sbin/atm/scspd/scsp_output.c,v 1.3 1999/08/28 01:15:33 peter Exp $
27 * @(#) $DragonFly: src/usr.sbin/atm/scspd/scsp_output.c,v 1.4 2004/12/18 22:48:02 swildner Exp $
28 */
29
30 /*
31 * Server Cache Synchronization Protocol (SCSP) Support
32 * ----------------------------------------------------
33 *
34 * Output packet processing
35 *
36 */
37
38 #include <sys/types.h>
39 #include <sys/param.h>
40 #include <sys/socket.h>
41 #include <net/ethernet.h>
42 #include <net/if.h>
43 #include <netinet/in.h>
44 #include <netatm/port.h>
45 #include <netatm/queue.h>
46 #include <netatm/atm.h>
47 #include <netatm/atm_if.h>
48 #include <netatm/atm_sap.h>
49 #include <netatm/atm_sys.h>
50 #include <netatm/atm_ioctl.h>
51
52 #include <errno.h>
53 #include <libatm.h>
54 #include <stdio.h>
55 #include <stdlib.h>
56 #include <string.h>
57 #include <syslog.h>
58 #include <unistd.h>
59
60 #include "scsp_msg.h"
61 #include "scsp_if.h"
62 #include "scsp_var.h"
63
64 /*
65 * Put a long integer into the output buffer
66 *
67 * This routine is provided for cases where long ints may not be
68 * word-aligned in the output buffer.
69 *
70 * Arguments:
71 * l long integer
72 * cp pointer to output buffer
73 *
74 * Returns:
75 * None
76 *
77 */
78 static void
79 put_long(u_long l, u_char *cp)
80 {
81 u_long nl;
82
83 /*
84 * Convert to network order and copy to output buffer
85 */
86 nl = htonl(l);
87 UM_COPY(&nl, cp, sizeof(u_long));
88 }
89
90
91 /*
92 * Format a Sender or Receiver ID
93 *
94 * Arguments:
95 * idp ponter to ID structure
96 * buff pointer to ID
97 *
98 * Returns:
99 * 0 input was invalid
100 * else length of ID processed
101 *
102 */
103 static int
104 scsp_format_id(Scsp_id *idp, char *buff)
105 {
106 /*
107 * Copy the ID
108 */
109 UM_COPY(idp->id, buff, idp->id_len);
110
111 /*
112 * Return the ID length
113 */
114 return(idp->id_len);
115 }
116
117
118 /*
119 * Format the Mandatory Common Part of an SCSP input packet
120 *
121 * Arguments:
122 * mcp pointer to MCP
123 * buff pointer to mandatory common part
124 *
125 * Returns:
126 * 0 input was invalid
127 * else length of MCP in message
128 *
129 */
130 static int
131 scsp_format_mcp(Scsp_mcp *mcp, char *buff)
132 {
133 int len;
134 char *odp;
135 struct scsp_nmcp *smp;
136
137 /*
138 * Set the protocol ID
139 */
140 smp = (struct scsp_nmcp *)buff;
141 smp->sm_pid = htons(mcp->pid);
142
143 /*
144 * Set the server group ID
145 */
146 smp->sm_sgid = htons(mcp->sgid);
147
148 /*
149 * Set the flags
150 */
151 smp->sm_flags = htons(mcp->flags);
152
153 /*
154 * Set the sender ID and length
155 */
156 smp->sm_sid_len = mcp->sid.id_len;
157 odp = buff + sizeof(struct scsp_nmcp);
158 len = scsp_format_id(&mcp->sid, odp);
159 if (len == 0) {
160 goto mcp_invalid;
161 }
162
163 /*
164 * Set the receiver ID and length
165 */
166 smp->sm_rid_len = mcp->rid.id_len;
167 odp += mcp->sid.id_len;
168 len = scsp_format_id(&mcp->rid, odp);
169 if (len == 0) {
170 goto mcp_invalid;
171 }
172
173 /*
174 * Set the record count
175 */
176 smp->sm_rec_cnt = htons(mcp->rec_cnt);
177
178 /*
179 * Return the length of data we processed
180 */
181 return(sizeof(struct scsp_nmcp) + mcp->sid.id_len +
182 mcp->rid.id_len);
183
184 mcp_invalid:
185 return(0);
186 }
187
188
189 /*
190 * Format an Extension
191 *
192 * Arguments:
193 * exp pointer to extension in internal format
194 * buff pointer to output buffer
195 * blen space available in buffer
196 *
197 * Returns:
198 * 0 input was invalid
199 * else length of extension processed
200 *
201 */
202 static int
203 scsp_format_ext(Scsp_ext *exp, char *buff, int blen)
204 {
205 struct scsp_next *sep;
206
207 /*
208 * Make sure there's room in the buffer
209 */
210 if (blen < (sizeof(struct scsp_next) + exp->len))
211 return(0);
212
213 /*
214 * Set the type
215 */
216 sep = (struct scsp_next *)buff;
217 sep->se_type = htons(exp->type);
218
219 /*
220 * Set the length
221 */
222 sep->se_len = htons(exp->len);
223
224 /*
225 * Set the value
226 */
227 if (exp->len > 0) {
228 buff += sizeof(struct scsp_next);
229 UM_COPY((caddr_t)exp + sizeof(Scsp_ext),
230 buff,
231 exp->len);
232 }
233
234 /*
235 * Return the number of bytes processed
236 */
237 return(sizeof(struct scsp_next) + exp->len);
238 }
239
240
241 /*
242 * Format the ATMARP part of a CSA record
243 *
244 * Arguments:
245 * acsp pointer to ATMARP protocol-specific CSA record
246 * buff pointer to output buffer
247 *
248 * Returns:
249 * 0 input was invalid
250 * else length of record processed
251 *
252 */
253 static int
254 scsp_format_atmarp(Scsp_atmarp_csa *acsp, char *buff)
255 {
256 char *cp;
257 int len, pkt_len;
258 struct scsp_atmarp_ncsa *sanp;
259
260 /*
261 * Figure out how long PDU is going to be
262 */
263 pkt_len = sizeof(struct scsp_atmarp_ncsa);
264 switch (acsp->sa_sha.address_format) {
265 case T_ATM_ENDSYS_ADDR:
266 pkt_len += acsp->sa_sha.address_length;
267 break;
268
269 case T_ATM_E164_ADDR:
270 pkt_len += acsp->sa_sha.address_length;
271 if (acsp->sa_ssa.address_format == T_ATM_ENDSYS_ADDR)
272 pkt_len += acsp->sa_ssa.address_length;
273 break;
274 }
275
276 switch (acsp->sa_tha.address_format) {
277 case T_ATM_ENDSYS_ADDR:
278 pkt_len += acsp->sa_tha.address_length;
279 break;
280
281 case T_ATM_E164_ADDR:
282 pkt_len += acsp->sa_tha.address_length;
283 if (acsp->sa_tha.address_format == T_ATM_ENDSYS_ADDR)
284 pkt_len += acsp->sa_tha.address_length;
285 break;
286 }
287
288 if (acsp->sa_spa.s_addr != 0)
289 pkt_len += sizeof(struct in_addr);
290
291 if (acsp->sa_tpa.s_addr != 0)
292 pkt_len += sizeof(struct in_addr);
293
294 /*
295 * Set up pointers
296 */
297 sanp = (struct scsp_atmarp_ncsa *)buff;
298 cp = (char *)sanp + sizeof(struct scsp_atmarp_ncsa);
299
300 /*
301 * Build fields
302 */
303 sanp->sa_hrd = htons(ARP_ATMFORUM);
304 sanp->sa_pro = htons(ETHERTYPE_IP);
305
306 /* sa_sha */
307 len = acsp->sa_sha.address_length;
308 switch (acsp->sa_sha.address_format) {
309 case T_ATM_ENDSYS_ADDR:
310 sanp->sa_shtl = ARP_TL_NSAPA | (len & ARP_TL_LMASK);
311
312 /* sa_sha */
313 UM_COPY(acsp->sa_sha.address, cp, len);
314 cp += len;
315
316 sanp->sa_sstl = 0;
317 break;
318
319 case T_ATM_E164_ADDR:
320 sanp->sa_shtl = ARP_TL_E164 | (len & ARP_TL_LMASK);
321
322 /* sa_sha */
323 UM_COPY(acsp->sa_sha.address, cp, len);
324 cp += len;
325
326 if (acsp->sa_ssa.address_format == T_ATM_ENDSYS_ADDR) {
327 len = acsp->sa_ssa.address_length;
328 sanp->sa_sstl = ARP_TL_NSAPA |
329 (len & ARP_TL_LMASK);
330
331 /* sa_ssa */
332 UM_COPY(acsp->sa_ssa.address, cp, len);
333 cp += len;
334 } else
335 sanp->sa_sstl = 0;
336 break;
337
338 default:
339 sanp->sa_shtl = 0;
340 sanp->sa_sstl = 0;
341 }
342
343 /* sa_state */
344 sanp->sa_state = acsp->sa_state;
345 sanp->sa_fill1 = 0;
346
347 /* sa_spa */
348 if (acsp->sa_spa.s_addr != 0) {
349 sanp->sa_spln = sizeof(struct in_addr);
350 UM_COPY(&acsp->sa_spa, cp, sizeof(struct in_addr));
351 cp += sizeof(struct in_addr);
352 }
353
354 /* sa_tha */
355 len = acsp->sa_tha.address_length;
356 switch (acsp->sa_tha.address_format) {
357 case T_ATM_ENDSYS_ADDR:
358 sanp->sa_thtl = ARP_TL_NSAPA | (len & ARP_TL_LMASK);
359
360 /* sa_tha */
361 UM_COPY(acsp->sa_tha.address, cp, len);
362 cp += len;
363
364 sanp->sa_tstl = 0;
365 break;
366
367 case T_ATM_E164_ADDR:
368 sanp->sa_thtl = ARP_TL_E164 | (len & ARP_TL_LMASK);
369
370 /* sa_tha */
371 UM_COPY(acsp->sa_tha.address, cp, len);
372 cp += len;
373
374 if (acsp->sa_tsa.address_format == T_ATM_ENDSYS_ADDR) {
375 len = acsp->sa_tha.address_length;
376 sanp->sa_tstl = ARP_TL_NSAPA |
377 (len & ARP_TL_LMASK);
378
379 /* sa_tsa */
380 UM_COPY(acsp->sa_tsa.address, cp, len);
381 cp += len;
382 } else
383 sanp->sa_tstl = 0;
384 break;
385
386 default:
387 sanp->sa_thtl = 0;
388 sanp->sa_tstl = 0;
389 }
390
391 /* sa_tpa */
392 if (acsp->sa_tpa.s_addr != 0) {
393 sanp->sa_tpln = sizeof(struct in_addr);
394 UM_COPY(&acsp->sa_tpa, cp, sizeof(struct in_addr));
395 }
396
397 return(pkt_len);
398 }
399
400
401 /*
402 * Format a Cache State Advertisement or Cache State Advertisement
403 * Summary record
404 *
405 * Arguments:
406 * csapp pointer to CSA or CSAS
407 * buff pointer to output buffer
408 *
409 * Returns:
410 * 0 input was invalid
411 * else length of record processed
412 *
413 */
414 static int
415 scsp_format_csa(Scsp_csa *csap, char *buff)
416 {
417 int len = 0;
418 char *odp;
419 struct scsp_ncsa *scp;
420
421 /*
422 * Set the hop count
423 */
424 scp = (struct scsp_ncsa *)buff;
425 scp->scs_hop_cnt = htons(csap->hops);
426
427 /*
428 * Set the null flag
429 */
430 if (csap->null) {
431 scp->scs_nfill = htons(SCSP_CSAS_NULL);
432 }
433
434 /*
435 * Set the sequence number
436 */
437 put_long(csap->seq, (u_char *)&scp->scs_seq);
438
439 /*
440 * Set the cache key
441 */
442 scp->scs_ck_len = csap->key.key_len;
443 odp = buff + sizeof(struct scsp_ncsa);
444 UM_COPY(csap->key.key, odp, scp->scs_ck_len);
445
446 /*
447 * Set the originator ID
448 */
449 odp += scp->scs_ck_len;
450 scp->scs_oid_len = scsp_format_id(&csap->oid, odp);
451
452 /*
453 * Set the protocol-specific data, if present. At the
454 * moment, we only handle data for ATMARP.
455 */
456 if (csap->atmarp_data) {
457 odp += scp->scs_oid_len;
458 len = scsp_format_atmarp(csap->atmarp_data, odp);
459 }
460
461 /*
462 * Set the record length
463 */
464 scp->scs_len = htons(sizeof(struct scsp_ncsa) +
465 scp->scs_ck_len + scp->scs_oid_len +
466 len);
467
468 /*
469 * Return the length of data we processed
470 */
471 return(ntohs(scp->scs_len));
472 }
473
474
475 /*
476 * Format a Cache Alignment message
477 *
478 * Arguments:
479 * cap pointer to CA message
480 * buff pointer to output buffer
481 * blen space available in buffer
482 *
483 * Returns:
484 * 0 input was invalid
485 * else length of CA message processed
486 *
487 */
488 static int
489 scsp_format_ca(Scsp_ca *cap, char *buff, int blen)
490 {
491 int i, len, proc_len;
492 struct scsp_nca *scap;
493 Scsp_csa *csap;
494
495 /*
496 * Set the sequence number
497 */
498 scap = (struct scsp_nca *)buff;
499 put_long(cap->ca_seq, (u_char *)&scap->sca_seq);
500 proc_len = sizeof(scap->sca_seq);
501 buff += sizeof(scap->sca_seq);
502
503 /*
504 * Set the flags
505 */
506 cap->ca_mcp.flags = 0;
507 if (cap->ca_m)
508 cap->ca_mcp.flags |= SCSP_CA_M;
509 if (cap->ca_i)
510 cap->ca_mcp.flags |= SCSP_CA_I;
511 if (cap->ca_o)
512 cap->ca_mcp.flags |= SCSP_CA_O;
513
514 /*
515 * Format the mandatory common part of the message
516 */
517 len = scsp_format_mcp(&cap->ca_mcp, buff);
518 if (len == 0)
519 goto ca_invalid;
520 buff += len;
521 proc_len += len;
522
523 /*
524 * Put any CSAS records into the message
525 */
526 for (i = 0, csap = cap->ca_csa_rec; i < cap->ca_mcp.rec_cnt;
527 i++, csap = csap->next) {
528 len = scsp_format_csa(csap, buff);
529 buff += len;
530 proc_len += len;
531 if (proc_len > blen) {
532 scsp_log(LOG_CRIT, "scsp_format_ca: buffer overflow");
533 abort();
534 }
535 }
536
537 /*
538 * Return the length of processed data
539 */
540 return(proc_len);
541
542 ca_invalid:
543 return(0);
544 }
545
546
547 /*
548 * Format a Cache State Update Request, Cache State Update Reply, or
549 * Cache State Update Solicit message. These all have the same format,
550 * a Mandatory Common Part followed by a number of CSA or CSAS records.
551 *
552 * Arguments:
553 * csup pointer to location to put pointer to CSU Req message
554 * buff pointer to output buffer
555 * blen space available in buffer
556 *
557 * Returns:
558 * 0 input was invalid
559 * else length of CSU Req message processed
560 *
561 */
562 static int
563 scsp_format_csu(Scsp_csu_msg *csup, char *buff, int blen)
564 {
565 int i, len, proc_len;
566 struct scsp_ncsu_msg *scsup;
567 Scsp_csa *csap;
568
569 /*
570 * Format the mandatory common part of the message
571 */
572 scsup = (struct scsp_ncsu_msg *)buff;
573 len = scsp_format_mcp(&csup->csu_mcp, buff);
574 if (len == 0)
575 goto csu_invalid;
576 buff += len;
577 proc_len = len;
578
579 /*
580 * Put the CSAS records into the message
581 */
582 for (i = 0, csap = csup->csu_csa_rec;
583 i < csup->csu_mcp.rec_cnt && csap;
584 i++, csap = csap->next) {
585 len = scsp_format_csa(csap, buff);
586 buff += len;
587 proc_len += len;
588 if (proc_len > blen) {
589 scsp_log(LOG_CRIT, "scsp_format_csu: buffer overflow");
590 abort();
591 }
592 }
593
594 /*
595 * Return the length of processed data
596 */
597 return(proc_len);
598
599 csu_invalid:
600 return(0);
601 }
602
603
604 /*
605 * Format a Hello message
606 *
607 * Arguments:
608 * hpp pointer to Hello message
609 * buff pointer to output buffer
610 * blen space available in buffer
611 *
612 * Returns:
613 * 0 input was invalid
614 * else length of Hello message processed
615 *
616 */
617 static int
618 scsp_format_hello(Scsp_hello *hp, char *buff, int blen)
619 {
620 int len, proc_len;
621 struct scsp_nhello *shp;
622 Scsp_id *ridp;
623
624 /*
625 * Set the hello interval
626 */
627 shp = (struct scsp_nhello *)buff;
628 shp->sch_hi = htons(hp->hello_int);
629
630 /*
631 * Set the dead factor
632 */
633 shp->sch_df = htons(hp->dead_factor);
634
635 /*
636 * Set the family ID
637 */
638 shp->sch_fid = htons(hp->family_id);
639
640 /*
641 * Process the mandatory common part of the message
642 */
643 proc_len = sizeof(struct scsp_nhello) -
644 sizeof(struct scsp_nmcp);
645 buff += proc_len;
646 len = scsp_format_mcp(&hp->hello_mcp, buff);
647 if (len == 0)
648 goto hello_invalid;
649 proc_len += len;
650 buff += len;
651
652 /*
653 * Add any additional receiver ID records to the message
654 */
655 for (ridp = hp->hello_mcp.rid.next; ridp;
656 ridp = ridp->next) {
657 len = scsp_format_id(ridp, buff);
658 if (len == 0) {
659 goto hello_invalid;
660 }
661 proc_len += len;
662 buff += len;
663 }
664
665 /*
666 * Return the length of the Hello message body
667 */
668 if (proc_len > blen) {
669 scsp_log(LOG_CRIT, "scsp_format_hello: buffer overflow");
670 abort();
671 }
672 return(proc_len);
673
674 hello_invalid:
675 return(0);
676 }
677
678
679 /*
680 * Format an SCSP output packet
681 *
682 * Arguments:
683 * dcsp pointer to DCS for which message is being prepared
684 * msg pointer to input packet
685 * bpp pointer to location to put pointer to formatted packet
686 *
687 * Returns:
688 * 0 input packet was invalid
689 * else length of formatted packet
690 *
691 */
692 int
693 scsp_format_msg(Scsp_dcs *dcsp, Scsp_msg *msg, char **bpp)
694 {
695 char *buff = NULL, *e_buff = NULL;
696 int buff_len, e_buff_len;
697 int e_len, len, plen;
698 struct scsp_nhdr *shp;
699 Scsp_ext *exp;
700
701 /*
702 * Allocate a buffer for the message
703 */
704 buff_len = dcsp->sd_server->ss_mtu;
705 buff = (char *)UM_ALLOC(buff_len);
706 if (!buff) {
707 scsp_mem_err("scsp_format_msg: dcsp->sd_server->ss_mtu");
708 }
709 UM_ZERO(buff, buff_len);
710 *bpp = buff;
711
712 /*
713 * Encode the fixed header
714 *
715 * Set the version
716 */
717 shp = (struct scsp_nhdr *)buff;
718 shp->sh_ver = SCSP_VER_1;
719
720 /*
721 * Set the message type
722 */
723 shp->sh_type = msg->sc_msg_type;
724
725 /*
726 * Point past the fixed header
727 */
728 len = sizeof(struct scsp_nhdr);
729 buff_len -= len;
730
731 /*
732 * Encode any extensions into a temporary buffer
733 */
734 e_len = 0;
735 if (msg->sc_ext) {
736 /*
737 * Get a buffer for the extensions
738 */
739 e_buff_len = 1024;
740 e_buff = (char *)UM_ALLOC(e_buff_len);
741 if (!buff) {
742 scsp_mem_err("scsp_format_msg: e_buff_len");
743 }
744 UM_ZERO(e_buff, e_buff_len);
745
746 /*
747 * Encode the extensions
748 */
749 for (exp = msg->sc_ext = 0; exp; exp = exp->next) {
750 plen = scsp_format_ext(exp, e_buff + e_len,
751 e_buff_len - e_len);
752 if (plen == 0) {
753 goto ignore;
754 }
755 e_len += plen;
756 }
757
758 /*
759 * Free the buffer if we didn't use it
760 */
761 if (!e_len) {
762 UM_FREE(e_buff);
763 e_buff = NULL;
764 }
765 }
766 buff_len -= e_len;
767
768 /*
769 * Encode the body of the message, depending on the type
770 */
771 switch(msg->sc_msg_type) {
772 case SCSP_CA_MSG:
773 plen = scsp_format_ca(msg->sc_ca, buff + len, buff_len);
774 break;
775 case SCSP_CSU_REQ_MSG:
776 case SCSP_CSU_REPLY_MSG:
777 case SCSP_CSUS_MSG:
778 plen = scsp_format_csu(msg->sc_csu_msg, buff + len,
779 buff_len);
780 break;
781 case SCSP_HELLO_MSG:
782 plen = scsp_format_hello(msg->sc_hello, buff + len,
783 buff_len);
784 break;
785 default:
786 goto ignore;
787 }
788 if (plen == 0) {
789 goto ignore;
790 }
791 len += plen;
792
793 /*
794 * Copy the extensions to the end of the message
795 */
796 if (e_len) {
797 shp->sh_ext_off = htons(len);
798 UM_COPY(e_buff, buff + len, e_len);
799 UM_FREE(e_buff);
800 }
801
802 /*
803 * Set the length
804 */
805 shp->sh_len = htons(len);
806
807 /*
808 * Compute the message checksum
809 */
810 shp->sh_checksum = htons(ip_checksum(buff, len));
811
812 /*
813 * Return the length of the buffer
814 */
815 return(len);
816
817 ignore:
818 if (buff)
819 UM_FREE(buff);
820 if (e_buff)
821 UM_FREE(e_buff);
822 *bpp = NULL;
823 return(0);
824 }
825
826
827 /*
828 * Send an SCSP message
829 *
830 * Arguments:
831 * dcsp pointer to DCS control block
832 * msg pointer to message to send
833 *
834 * Returns:
835 * 0 success
836 * errno error encountered
837 *
838 */
839 int
840 scsp_send_msg(Scsp_dcs *dcsp, Scsp_msg *msg)
841 {
842 int len, rc;
843 char *buff;
844
845 /*
846 * Make sure we have a socket open
847 */
848 if (dcsp->sd_sock == -1) {
849 return(EBADF);
850 }
851
852 /*
853 * Trace the message
854 */
855 if (((scsp_trace_mode & SCSP_TRACE_HELLO_MSG) &&
856 msg->sc_msg_type == SCSP_HELLO_MSG) ||
857 ((scsp_trace_mode & SCSP_TRACE_CA_MSG) &&
858 msg->sc_msg_type != SCSP_HELLO_MSG)) {
859 scsp_trace_msg(dcsp, msg, 0);
860 scsp_trace("\n");
861 }
862
863 /*
864 * Put the message into network format
865 */
866 len = scsp_format_msg(dcsp, msg, &buff);
867 if (len == 0) {
868 scsp_log(LOG_ERR, "scsp_send_msg: message conversion failed\n");
869 abort();
870 }
871
872 /*
873 * Write the message to the DCS
874 */
875 rc = write(dcsp->sd_sock, (void *)buff, len);
876 UM_FREE(buff);
877 if (rc == len || (rc == -1 && errno == EINPROGRESS)) {
878 rc = 0;
879 } else {
880 /*
881 * There was an error on the write--close the VCC
882 */
883 close(dcsp->sd_sock);
884 dcsp->sd_sock = -1;
885
886 /*
887 * Inform the Hello FSM
888 */
889 scsp_hfsm(dcsp, SCSP_HFSM_VC_CLOSED, NULL);
890
891 /*
892 * Set the return code
893 */
894 if (rc == -1)
895 rc = errno;
896 else
897 rc = EINVAL;
898 }
899
900 return(rc);
901 }
DragonFly BSD