/*----------------------------------------------------------------------* rtp_net_is_connected *----------------------------------------------------------------------*/ unsigned rtp_net_is_connected (RTP_SOCKET sockHandle) { struct sockaddr_in peerAddr; int peerLen; #ifdef DO_IFACE_CHECK while (IP_IFaceIsReady() == 0) { OS_Delay(100); } #endif peerLen = sizeof(peerAddr); memset(&peerAddr, 0, peerLen); if (getpeername ((int) sockHandle, (struct sockaddr *) &peerAddr, &peerLen) == 0) { /* this is necessary but not sufficient; now check to make sure the other side hasn't shutdown sending data to us */ fd_set tempSet; long selectTime=0; int result; IP_FD_ZERO(&tempSet); IP_FD_SET((int) sockHandle, &tempSet); // check the socket for ready-to-read result = select(&tempSet, 0, 0, selectTime); if (result != -1) { unsigned char tempBuffer[1]; if (!IP_FD_ISSET((int) sockHandle, &tempSet)) { // if we would block, then there is no problem; if the other // side has shut down its end of the connection, we would // return immediately with an error code return (1); } // find out whether this means that: // 1. there is data in the buffer from the other side // 2. the connection has been closed result = recv ((int) sockHandle, tempBuffer, 1, MSG_PEEK); if (result == 1) { // there is data return (1); } if (result == -1) { return (1); } } } return (0); }
void _rtp_to_fd_set (fd_set *set, RTP_FD_SET *rtp) { int index; IP_FD_ZERO(set); for (index = 0; index < (signed) rtp->fdCount && index < FD_SETSIZE; index++) { IP_FD_SET((int) rtp->fdArray[index], set); } }
/*----------------------------------------------------------------------* rtp_net_read_select *----------------------------------------------------------------------*/ int rtp_net_read_select (RTP_HANDLE sockHandle, long msecTimeout) { #ifdef LINUXTOBEIMPLEMENTED long selectTime; fd_set read_set; int result; /* ----------------------------------- */ /* write list */ /* ----------------------------------- */ IP_FD_ZERO(&read_set); IP_FD_SET((SOCKET) sockHandle, &read_set); #ifdef RTP_DEBUG /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ WSASetLastError(0); #endif if (msecTimeout >= 0) { selectTime = msecTimeout / 1000; result = select(1, (fd_set *) &read_set, (fd_set *) 0, (fd_set *) 0, selectTime); } else { result = select(1, (fd_set *) &read_set, (fd_set *) 0, (fd_set *) 0, 0); } /* if an error or if it timed out */ if ((result == SOCKET_ERROR) || (result == 0)) { #ifdef RTP_DEBUG result = WSAGetLastError(); RTP_DEBUG_OUTPUT_STR("rtp_net_read_select: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); #else return (0); #endif }
/*----------------------------------------------------------------------* rtp_net_select *----------------------------------------------------------------------*/ int rtp_net_select (RTP_FD_SET *readList, RTP_FD_SET *writeList, RTP_FD_SET *errorList, long msecTimeout) { long selectTime; int result; int index; fd_set write_set; fd_set read_set; fd_set error_set; IP_FD_ZERO(&write_set); IP_FD_ZERO(&read_set); IP_FD_ZERO(&error_set); /* ----------------------------------- */ /* write list */ /* ----------------------------------- */ if (writeList) { _rtp_to_fd_set(&write_set, writeList); } /* ----------------------------------- */ /* read list */ /* ----------------------------------- */ if (readList) { _rtp_to_fd_set(&read_set, readList); } /* ----------------------------------- */ /* error list */ /* ----------------------------------- */ if (errorList) { _rtp_to_fd_set(&error_set, errorList); } if (msecTimeout >= 0) { selectTime = msecTimeout / 1000; // seconds result = select((fd_set *) &read_set, (fd_set *) &write_set, (fd_set *) &error_set, selectTime); } else { result = select((fd_set *) &read_set, (fd_set *) &write_set, (fd_set *) &error_set, 0); } if (result >=0) { if (writeList) { _fd_set_to_rtp(writeList, &write_set); } if (readList) { _fd_set_to_rtp(readList, &read_set); } if (errorList) { _fd_set_to_rtp(errorList, &error_set); } } if (result == -1) { //int errVal = _rtp_get_last_socket_error(sockHandle); #ifdef RTP_DEBUG RTP_DEBUG_OUTPUT_STR("rtp_net_select: error returned "); RTP_DEBUG_OUTPUT_INT(errVal); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (result); }
/* *=========================================================================== * ipl2tps *=========================================================================== * Description: * Parameters: * Returns: * */ IP_STATIC IPCOM_PROCESS(ipl2tps) { Ip_fd ipd_fd = IP_INVALID_SOCKET; Ip_bool ipd_init = 0; #ifdef IPPPP_USE_PPPL2TP Ip_fd ipl2tp_ppp_ipc_recv_fd = IP_INVALID_SOCKET; #endif ipcom_proc_init(); #ifdef IPPPP_USE_PPPL2TP if ((ipl2tp_ppp_ipc_recv_fd = ipppp_pppl2tp_pkt_que_open()) == IP_INVALID_SOCKET) { ipcom_printf("Cannot allocate data packet output socket, errno: %d"IP_LF, ipcom_errno); goto leave; } #endif /* Get socket */ if ((udp_fd = ipcom_socket(IP_AF_INET, IP_SOCK_DGRAM, IP_IPPROTO_UDP)) < 0) { ipcom_printf("Cannot allocate socket, errno: %d"IP_LF, ipcom_errno); goto leave; } else { union Ip_sockaddr_union uaddr; /* Bind to L2TP port */ ipcom_memset(&uaddr, 0, sizeof(uaddr)); uaddr.sin.sin_family = IP_AF_INET; uaddr.sin.sin_addr.s_addr = IP_INADDR_ANY; uaddr.sin.sin_port = ip_htons(IPL2TP_PORT_NUMBER); uaddr.sin.sin_len = sizeof(struct Ip_sockaddr_in); if (ipcom_bind(udp_fd, &uaddr.sa, sizeof(struct Ip_sockaddr_in)) < 0) { ipcom_printf("Cannot bind socket, errno: %d"IP_LF, ipcom_errno); ipcom_socketclose(udp_fd); goto leave; } } /* Get socket */ if ((ip_fd = ipcom_socket(IP_AF_INET, IP_SOCK_RAW, IP_IPPROTO_L2TP)) < 0) { ipcom_printf("Cannot allocate socket, errno: %d"IP_LF, ipcom_errno); ipcom_socketclose(udp_fd); goto leave; } /* Init IPD */ if (ipd_init == 0 && ipcom_ipd_init("ipl2tp", IPCOM_SUCCESS, &ipd_fd) != IPCOM_SUCCESS) { ipcom_printf("Cannot initialize ipd: %s"IP_LF, ipcom_strerror(ipcom_errno)); goto leave; } ipd_init = 1; /* Enter read loop (never return) */ for (;;) { Ip_fd_set fds; Ipl2tp_example_fd_entry_t *fd; int fd_max; struct Ip_timeval tv; int ret; IP_FD_ZERO(&fds); IP_FD_SET(udp_fd, &fds); IP_FD_SET(ip_fd, &fds); IP_FD_SET(ipd_fd, &fds); fd_max = IP_MAX(udp_fd, ip_fd); fd_max = IP_MAX(fd_max, ipd_fd); #ifdef IPPPP_USE_PPPL2TP IP_FD_SET(ipl2tp_ppp_ipc_recv_fd, &fds); fd_max = IP_MAX(fd_max, ipl2tp_ppp_ipc_recv_fd); #endif fd = IPCOM_LIST_FIRST(&ipl2tp_example_fds); while (fd != IP_NULL) { Ipl2tp_example_fd_entry_t *nfd = IPCOM_LIST_NEXT(&fd->next); if (fd->data != IP_NULL) { IP_FD_SET(fd->fd, &fds); fd_max = IP_MAX(fd_max, fd->fd); } else { ipcom_list_remove(&fd->next); ipcom_socketclose(fd->fd); ipcom_free(fd); } fd = nfd; } tv.tv_sec = 0; tv.tv_usec = 10000; if ((ret = ipcom_socketselect(fd_max + 1, &fds, IP_NULL, IP_NULL, &tv)) > 0) { union Ip_sockaddr_union uaddr; int length; Ip_u8 *buffer; if (IP_FD_ISSET(ipd_fd, &fds)) { int event; event = ipcom_ipd_input(ipd_fd); if (event == IPCOM_IPD_EVENT_RECONFIGURE) goto leave; } #ifdef IPPPP_USE_PPPL2TP if (IP_FD_ISSET(ipl2tp_ppp_ipc_recv_fd, &fds)) { Ipppp_pppl2tp_pkt_que_entry que_entry; Ipcom_netif *netif; Ipcom_pkt *pkt; char addrstr[IP_INET_ADDRSTRLEN]; /* Read message and feed it to L2TP main input */ if (ipppp_pppl2tp_pkt_que_recv(&que_entry, &uaddr) == IPCOM_SUCCESS) { if ((que_entry.netif == IP_NULL) || (que_entry.pkt == IP_NULL)) { ipcom_printf("ipl2tps: L2TPv2 pkt from %s:%d contains null ptr(s)."IP_LF, ipcom_inet_ntop(IP_AF_INET, &uaddr.sin.sin_addr, addrstr, sizeof(addrstr)), ipcom_ntohs(uaddr.sin.sin_port)); } else { pkt = que_entry.pkt; netif = que_entry.netif; ipppp_pppl2tp_output(netif, pkt); } } else ipcom_printf("ipl2tps: PPP pkt recv failed."IP_LF); } #endif /* IPPPP_USE_PPPL2TP */ if (IP_FD_ISSET(udp_fd, &fds)) { /* Read message and feed it to L2TP main input */ if ((length = ipl2tp_l2tp_read(udp_fd, &buffer, &uaddr)) > 0) { ipl2tp_api_l2tp_input(buffer, buffer + HEADER_SPACE, (Ip_u16)length, &uaddr, IPL2TP_ATTR_TRANSPORT_UDP); /* Free buffer if not in PPP output queue */ if (ipl2tp_buffer_free) { ipl2tp_cache_free(buffer); } } } if (IP_FD_ISSET(ip_fd, &fds)) { /* Read message and feed it to L2TP main input */ if ((length = ipl2tp_l2tp_read(ip_fd, &buffer, &uaddr)) > 0) { /* Remove the IP header before invoking */ ipl2tp_api_l2tp_input(buffer, buffer + HEADER_SPACE + 20, (Ip_u16)(length - 20), &uaddr, IPL2TP_ATTR_TRANSPORT_IP); /* Free buffer if not in PPP output queue */ if (ipl2tp_buffer_free) { ipl2tp_cache_free(buffer); } } } fd = IPCOM_LIST_FIRST(&ipl2tp_example_fds); while (fd != IP_NULL) { Ipl2tp_example_fd_entry_t *nfd = IPCOM_LIST_NEXT(&fd->next); if (fd->data!= IP_NULL && IP_FD_ISSET(fd->fd, &fds)) { /* Read message and feed it to L2TP main input */ if ((length = ipl2tp_l2tp_read(fd->fd, &buffer, &uaddr)) > 0) { if (fd->data != IP_NULL) { (*fd->data) (fd, buffer, buffer + HEADER_SPACE, length); } /* Free buffer if not in PPP output queue */ if (ipl2tp_buffer_free) { ipl2tp_cache_free(buffer); } } } fd = nfd; } } else if (ret < 0) { ipcom_printf("select error"IP_LF); } } leave: /* Have to call ipd init if not done yet */ if (ipd_init == 0 && ipcom_ipd_init("ipl2tp", IPCOM_ERR_FAILED, &ipd_fd) == IPCOM_SUCCESS) { ipd_init = 1; } if (ipd_init != 0) { (void)ipcom_ipd_exit("ipl2tp", ipd_fd); } ipcom_proc_exit(); }
/* *=========================================================================== * ipcom_cmd_sockperf_accept *=========================================================================== * Description: Passive open of socket(s). * Parameters: * Returns: */ IP_STATIC void ipcom_cmd_sockperf_accept(Ipcom_cmd_sockperf_t *cmd) { Ip_fd *s = cmd->sock_array; int listen_sock; Ip_u32 accepted_sockets = 0; struct Ip_timeval start; struct Ip_timeval stop; int on = 1; listen_sock = ipcom_socket(cmd->res->ai_family, cmd->res->ai_socktype, cmd->res->ai_protocol); if (listen_sock == IP_SOCKERR) { ipcom_printf("sockperf-a: Failed to create socket: %s"IP_LF, ipcom_strerror(ipcom_errno)); goto cleanup; } if (ipcom_setsockopt(listen_sock, IP_SOL_SOCKET, IP_SO_REUSEADDR, &on, sizeof(on)) < 0) { ipcom_printf("sockperf-a: setsockopt IP_SO_REUSEADDR failed : %s"IP_LF, ipcom_strerror(ipcom_errno)); return; } if (ipcom_bind(listen_sock, cmd->res->ai_addr, cmd->res->ai_addrlen) < 0) { ipcom_printf("sockperf-a: Failed to bind: %s"IP_LF, ipcom_strerror(ipcom_errno)); goto cleanup; } if (ipcom_listen(listen_sock, cmd->num_sock) < 0) { ipcom_printf("sockperf-a: Failed to listen: %s"IP_LF, ipcom_strerror(ipcom_errno)); goto cleanup; } ipcom_printf("sockperf-a: listen on %s[%d]"IP_LF, cmd->res->ai_canonname, ip_ntohs(((struct Ip_sockaddr_in *)cmd->res->ai_addr)->sin_port)); IP_FD_ZERO(&cmd->read_set); IP_FD_SET(listen_sock, &cmd->read_set); if (ipcom_socketselect(listen_sock + 1, &cmd->read_set, IP_NULL, IP_NULL, IP_NULL) != 1) { ipcom_printf("sockperf-a: Select failed for listen socket: %s"IP_LF, ipcom_strerror(ipcom_errno)); goto cleanup; } ipcom_microtime(&start); for (;accepted_sockets < cmd->num_sock; accepted_sockets++) { s[accepted_sockets] = ipcom_accept(listen_sock, IP_NULL, IP_NULL); if (s[accepted_sockets] == IP_SOCKERR) { ipcom_printf("sockperf-a: Failed to create socket: %s"IP_LF, ipcom_strerror(ipcom_errno)); goto cleanup; } if (ipcom_setsockopt(s[accepted_sockets], IP_SOL_SOCKET, IP_SO_LINGER, &cmd->linger, sizeof(cmd->linger)) < 0) { ipcom_printf("sockperf-a: setsockopt SO_LINGER failed : %s"IP_LF, ipcom_strerror(ipcom_errno)); goto cleanup; } } ipcom_microtime(&stop); ipcom_printf("sockperf-a: %ld sockets accepted in %ld ms"IP_LF, accepted_sockets, ipcom_cmd_sockperf_tv_to_msec(&start, &stop)); ipcom_cmd_sockperf_run(cmd); cleanup: if (listen_sock >= 0) (void)ipcom_socketclose(listen_sock); while (accepted_sockets-- > 0) (void)ipcom_socketclose(s[accepted_sockets]); }
/* *=========================================================================== * ipcom_cmd_sockperf_run *=========================================================================== * Description: Sends/receives data. * Parameters: * Returns: */ IP_STATIC void ipcom_cmd_sockperf_run(Ipcom_cmd_sockperf_t *cmd) { struct Ip_timeval tmo = { 0, 0 }; struct Ip_timeval *ptmo; struct Ip_timeval start; struct Ip_timeval stop; Ip_u32 i; Ip_u32 c; int num_ready; Ip_fd *s = cmd->sock_array; Ip_u32 total_bytes_to_send = cmd->num_buf * cmd->buf_len; Ip_u32 finished_sockets = 0; Ip_u32 total_bytes_read = 0; Ip_ssize_t bytes; Ip_fd_set read_set; int send_flags = (cmd->transmit && cmd->receive) ? IP_MSG_DONTWAIT : 0; if (cmd->transmit) ipcom_printf("sockperf-t: send buffer is %u"IP_LF, cmd->sendbuf_size); if (cmd->receive) ipcom_printf("sockperf-r: receive buffer is %u"IP_LF, cmd->sendbuf_size); for (i = 0; i < cmd->num_sock; i++) { int on = 1; if (ipcom_setsockopt(s[i], IP_SOL_SOCKET, IP_SO_REUSEADDR, &on, sizeof(on)) < 0) { ipcom_printf("sockperf-c: setsockopt IP_SO_REUSEADDR failed : %s"IP_LF, ipcom_strerror(ipcom_errno)); return; } if (ipcom_setsockopt(s[i], IP_SOL_SOCKET, IP_SO_SNDBUF, &cmd->sendbuf_size, sizeof(cmd->sendbuf_size)) < 0) { ipcom_printf("sockperf-c: setsockopt IP_SO_SNDBUF failed : %s"IP_LF, ipcom_strerror(ipcom_errno)); return; } if (ipcom_setsockopt(s[i], IP_SOL_SOCKET, IP_SO_RCVBUF, &cmd->recvbuf_size, sizeof(cmd->recvbuf_size)) < 0) { ipcom_printf("sockperf-c: setsockopt IP_SO_SNDBUF failed : %s"IP_LF, ipcom_strerror(ipcom_errno)); return; } } if (cmd->receive) { IP_FD_ZERO(&cmd->read_set); cmd->width = s[0]; IP_FD_SET(s[0], &cmd->read_set); for (i = 1; i < cmd->num_sock; i++) if (s[i] != IP_INVALID_SOCKET) { cmd->width = IP_MAX(cmd->width, s[i]); IP_FD_SET(s[i], &cmd->read_set); } } ipcom_microtime(&start); while ((cmd->transmit && total_bytes_to_send) || (cmd->receive && finished_sockets < cmd->num_sock)) { if (cmd->transmit && total_bytes_to_send) { for (i = 0; i < cmd->num_sock; i++) { if (cmd->testpattern) { /* Test patter is "[B|E|D]xxxxxx ", B = first 8 byte in buffer, E = last 8 bytes, D = all other */ for (c = 0; c < cmd->buf_len; c += 8) ipcom_sprintf(cmd->buf + c, "%c%06ld ", c == 0 ? '>' : (c >= cmd->buf_len - 8 ? '<' : '#'), cmd->send_pattern[i]++ % 1000000); } bytes = ipcom_send(s[i], cmd->buf, IP_MIN(cmd->buf_len, total_bytes_to_send), send_flags); if (bytes < 0 && ipcom_errno == IP_ERRNO_EWOULDBLOCK) (void)ipcom_sleep(0); else { if (bytes < 0) { ipcom_printf("sockperf-t: send failed : %s"IP_LF, ipcom_strerror(ipcom_errno)); return; } total_bytes_to_send -= bytes; } } if (cmd->receive && total_bytes_to_send == 0) for (i = 0; i < cmd->num_sock; i++) if (ipcom_shutdown(s[i], IP_SHUT_WR) < 0) { ipcom_printf("sockperf-t: shutdown failed: %s"IP_LF, ipcom_strerror(ipcom_errno)); return; } } if (cmd->receive) { ptmo = IP_NULL; while (finished_sockets < cmd->num_sock) { read_set = cmd->read_set; num_ready = ipcom_socketselect(cmd->width + 1, &read_set, IP_NULL, IP_NULL, ptmo); if (num_ready == 0) break; if (num_ready < 0) { ipcom_printf("sockperf-r: select failed: %s"IP_LF, ipcom_strerror(ipcom_errno)); return; } for (i = 0; i < cmd->num_sock; i++) { if (IP_FD_ISSET(s[i], &read_set)) { bytes = ipcom_recv(s[i], cmd->buf, cmd->buf_len, 0); if (bytes < 0) { ipcom_printf("sockperf-r: recv failed: %s"IP_LF, ipcom_strerror(ipcom_errno)); return; } if (cmd->testpattern) { if (cmd->echo) ipcom_cmd_sockperf_echo_buf(cmd->buf, bytes, cmd->recv_pattern[i]); for (c = 0; c < (Ip_u32)bytes; c += 8) { if (cmd->buf[c] != '#' && cmd->buf[c] != '>' && cmd->buf[c] != '<') { ipcom_printf("\nsockperf-r: test pattern error, expected B, D or E found %c(%d) offset %ld"IP_LF, cmd->buf[c], (int)cmd->buf[c], c); ipcom_cmd_sockperf_echo_buf(cmd->buf, bytes, 0); return; } if (ipcom_atoi(cmd->buf + c + 1) != (int)(cmd->recv_pattern[i]++ % 1000000)) { ipcom_printf("\nsockperf-r: test pattern error, was %d should be %ld offset %ld"IP_LF, ipcom_atoi(cmd->buf + c + 1), (cmd->recv_pattern[i] - 1) % 1000000, c); ipcom_cmd_sockperf_echo_buf(cmd->buf, bytes, 0); return; } } } if (bytes > 0) total_bytes_read += bytes; else { finished_sockets++; IP_FD_CLR(s[i], &cmd->read_set); } } } if (cmd->transmit && total_bytes_to_send) ptmo = &tmo; } } } ipcom_microtime(&stop); if (cmd->transmit) ipcom_printf("sockperf-t: %lu bytes sent in %ld ms (%lu kbyte/s)"IP_LF, cmd->num_buf * cmd->buf_len, ipcom_cmd_sockperf_tv_to_msec(&start, &stop), cmd->num_buf * cmd->buf_len / (Ip_u32)ipcom_cmd_sockperf_tv_to_msec(&start, &stop) * 1000 / 1024); if (cmd->receive) ipcom_printf("sockperf-r: %lu bytes read in %ld ms (%lu kbyte/s)"IP_LF, total_bytes_read, ipcom_cmd_sockperf_tv_to_msec(&start, &stop), total_bytes_read / (Ip_u32)ipcom_cmd_sockperf_tv_to_msec(&start, &stop) * 1000 / 1024); }
IP_PUBLIC int ipcom_socketpair_tcp(int fd[2]) { int server; union Ip_sockaddr_union sock; Ip_socklen_t socklen; Ip_bool connected = IP_FALSE; int opt; struct Ip_addrinfo hints; struct Ip_addrinfo *res = IP_NULL; fd[0] = fd[1] = server = -1; ipcom_memset(&hints, 0, sizeof(hints)); hints.ai_socktype = IP_SOCK_STREAM; if (ipcom_getaddrinfo(IP_NULL, "0", &hints, &res) != 0) goto failed; /* Server socket */ server = ipcom_socket(res->ai_family, res->ai_socktype, res->ai_protocol); if (server == -1) goto failed; opt = 1; (void)ipcom_setsockopt(server, IP_SOL_SOCKET, IP_SO_REUSEADDR, &opt, sizeof(opt)); if (ipcom_bind(server, res->ai_addr, res->ai_addrlen) != 0) goto failed; if (ipcom_listen(server, 1) != 0) goto failed; socklen = res->ai_addrlen; if (ipcom_getsockname(server, &sock.sa, &socklen) != 0) goto failed; /* Client socket */ fd[1] = ipcom_socket(res->ai_family, res->ai_socktype, res->ai_protocol); if (fd[1] == -1) goto failed; opt = 1; (void)ipcom_setsockopt(fd[1], IP_SOL_SOCKET, IP_SO_REUSEADDR, &opt, sizeof(opt)); opt = 1; (void)ipcom_socketioctl(fd[1], IP_FIONBIO, &opt); if (ipcom_connect(fd[1], &sock.sa, socklen) == -1) { if (ipcom_errno != IP_ERRNO_EINPROGRESS) goto failed; } else connected = IP_TRUE; /* Spawn socket */ fd[0] = ipcom_accept(server, IP_NULL, IP_NULL); if (fd[0] == -1) goto failed; opt = 1; (void)ipcom_setsockopt(fd[0], IP_SOL_SOCKET, IP_SO_REUSEADDR, &opt, sizeof(opt)); ipcom_socketclose(server); /* Client socket revisited */ if (connected == IP_FALSE) { Ip_fd_set write_set; IP_FD_ZERO(&write_set); IP_FD_SET(fd[1], &write_set); if (ipcom_socketselect(fd[1] + 1, IP_NULL, &write_set, IP_NULL, IP_NULL) != 1) goto failed; } opt = 0; (void)ipcom_socketioctl(fd[1], IP_FIONBIO, &opt); if (res != IP_NULL) ipcom_freeaddrinfo(res); return 0; failed: if (res != IP_NULL) ipcom_freeaddrinfo(res); if (fd[0] != -1) ipcom_socketclose(fd[0]); if (fd[1] != -1) ipcom_socketclose(fd[1]); if (server != -1) ipcom_socketclose(server); return -1; }