/* * Setup RTSP(S) connection */ static int iptv_rtsp_start ( iptv_mux_t *im, const char *raw, const url_t *u ) { rtsp_priv_t *rp; http_client_t *hc; udp_connection_t *rtp, *rtcp; int r; if (!(hc = http_client_connect(im, RTSP_VERSION_1_0, u->scheme, u->host, u->port, NULL))) return SM_CODE_TUNING_FAILED; if (u->user) hc->hc_rtsp_user = strdup(u->user); if (u->pass) hc->hc_rtsp_pass = strdup(u->pass); if (udp_bind_double(&rtp, &rtcp, "IPTV", "rtp", "rtcp", NULL, 0, NULL, 128*1024, 16384, 4*1024, 4*1024) < 0) { http_client_close(hc); return SM_CODE_TUNING_FAILED; } hc->hc_hdr_received = iptv_rtsp_header; hc->hc_data_received = iptv_rtsp_data; hc->hc_handle_location = 1; /* allow redirects */ hc->hc_rtsp_keep_alive_cmd = RTSP_CMD_GET_PARAMETER; /* start keep alive loop with GET_PARAMETER */ http_client_register(hc); /* register to the HTTP thread */ r = rtsp_setup(hc, u->path, u->query, NULL, ntohs(IP_PORT(rtp->ip)), ntohs(IP_PORT(rtcp->ip))); if (r < 0) { udp_close(rtcp); udp_close(rtp); http_client_close(hc); return SM_CODE_TUNING_FAILED; } rp = calloc(1, sizeof(*rp)); rp->rtcp_info = calloc(1, sizeof(iptv_rtcp_info_t)); rtcp_init(rp->rtcp_info); rp->rtcp_info->connection = rtcp; rp->hc = hc; udp_multirecv_init(&rp->um, IPTV_PKTS, IPTV_PKT_PAYLOAD); rp->path = strdup(u->path ?: ""); rp->query = strdup(u->query ?: ""); im->im_data = rp; im->mm_iptv_fd = rtp->fd; im->mm_iptv_connection = rtp; im->mm_iptv_fd2 = rtcp->fd; im->mm_iptv_connection2 = rtcp; return 0; }
/* start a new listen server to get the list */ int ogc_init (char *localport, char *server, char *port, char *game, int ai_family) { int i; ogc_sock = -1; ogc_sock = udp_server (localport, ai_family); d_printf ("ogc_init (Localport: %s, Server %s:%s Game %s socket=%d)\n", localport, server, port, game, ogc_sock); if (ogc_sock <= 0) return 0; strncpy (ogc_host, server, LEN_OGCHOST); strncpy (ogc_port, port, LEN_OGCPORT); strncpy (ogc_game, game, LEN_GAME); ogc_ai_family = ai_family; d_printf ("ogc_host:%s ogc_port:%s ogc_game:%s ogc_ai_family:%d\n", ogc_host, ogc_port, ogc_game, ogc_ai_family); if (dns_filladdr (ogc_host, LEN_OGCHOST, ogc_port, LEN_OGCPORT, ogc_ai_family, &ogc_addr) < 0) { udp_close (ogc_sock); ogc_sock = -1; return 0; } for (i = 0; i < MAX_OGC_ENTRYS; i++) ogc_array[i].serial = -1; return 1; };
/* FUNCTION: dhcpc_close() * * Cleanup various data structures associated with the DHCP client module. * * PARAM1: unsigned int close flags * * RETURNS: int 0 if OK, else error code */ int dhcpc_close(uint32_t flags) { int err = 0; /* terminate the UDP lightweight API registration */ if (dhc_conn) { udp_close(dhc_conn); dhc_conn = NULL; } /* zero out the DHCP client state structures */ MEMSET(&dhc_states[0], 0, sizeof(dhc_states)); xids = DC_INITIAL_XID; /* zero out DHCP client statistics */ MEMSET(&dhc_stats, 0, sizeof(dhc_stats)); #ifdef USE_UPNP /* cleanup data structures */ #ifdef USE_AUTOIP MEMSET(autoIPs, 0, sizeof (autoIPs)); dBASE_AUTO_IP_ADDRESS = AUTOIP_BASE_ADDR; dMAX_AUTO_IP_ADDRESS = AUTOIP_MAX_ADDR; rand_seed = 0; #endif MEMSET(upnp, 0, sizeof (upnp)); #ifndef USER_DS_SUPPORT MEMSET(ds_structs, 0, sizeof (ds_structs)); #endif upnp_started = 0; #endif return (err); }
static void eap_wps_deinit(struct eap_sm *sm, void *priv) { wpa_printf(MSG_DEBUG,"@#*@#*@#*EAP-WPS: Entered eap_wps_reset *#@*#@*#@"); struct eap_wps_data *data = (struct eap_wps_data *)priv; if (data == NULL) return; if (data->udpFdEap != -1) { udp_close(data->udpFdEap); data->udpFdEap = -1; } /* if (data->udpFdCom != -1) { eloop_unregister_read_sock(data->udpFdCom); udp_close(data->udpFdCom); data->udpFdCom = -1; } */ os_free(data); }
static int _tftp_close(tftp_info_t *info) { ebuf_t *buf; const char *emsg = "transfer cancelled"; /* some error message */ if (info->tftp_socket == -1) return 0; if (info->tftp_filemode == FILE_MODE_READ) { buf = udp_alloc(); if (buf) { /* If we're on the EOF packet, just send an ack */ if (info->tftp_lastblock) { ebuf_append_u16_be(buf,TFTP_OP_ACK); ebuf_append_u16_be(buf,info->tftp_blknum); } else { ebuf_append_u16_be(buf,TFTP_OP_ERROR); ebuf_append_u16_be(buf,TFTP_ERR_DISKFULL); ebuf_append_bytes(buf,emsg,strlen(emsg)+1); } udp_send(info->tftp_socket,buf,info->tftp_ipaddr); } } else { /* Just flush out the remaining write data, if any */ _tftp_writemore(info); } udp_close(info->tftp_socket); info->tftp_socket = -1; return 0; }
void TrapList::deInitial(void) { if( inited ) { os_tsk_delete(tsk_send_trap); udp_close(soc_massage); udp_release_socket(soc_massage); } }
extern int send_rescueack(unsigned short no, unsigned short lo) { ebuf_t *buf = NULL; int acksocket; char tftpnull; int res, i; /* * Open a UDP socket to the TFTP server */ acksocket = udp_socket(UDP_PROTO_TFTP); res = udp_bind(acksocket, 69); if (res < 0) { return res; } udp_connect(acksocket, ackport); for (i = 0; i < 1; i++) { buf = udp_alloc(); if (!buf) return -1; /* * Send the data */ ebuf_append_u16_be(buf, no); ebuf_append_u16_be(buf, lo); ebuf_append_bytes(buf,&tftpnull, 0); udp_send(acksocket ,buf, tftpipto); } if (buf) udp_free(buf); udp_close(acksocket); return 0; }
static void rtp_close( hnd_t handle ) { obe_rtp_ctx *p_rtp = handle; udp_close( p_rtp->udp_handle ); free( p_rtp ); }
int syscall_handler(int num, struct syscall_arguments *args) { interrupt_unmask(); switch (num) { case ADDPROCESS: interrupt_mask(); process_add((void (*)())args->arg1); interrupt_unmask(); break; case YIELD: interrupt_sleepinsyscall(); break; case UDPSEND: return udp_output(args->arg1, (struct sockaddr*)args->arg2, (char *)args->arg3, args->arg4); break; case UDPRECV: return udp_recvfrom(args->arg1, (struct sockaddr*)args->arg2, (char *)args->arg3, args->arg4); break; case UDPSOCKET: return udp_socket(); break; case UDPBIND: return udp_bind(args->arg1, (struct sockaddr*)args->arg2); break; case UDPCLOSE: return udp_close(args->arg1); break; case TCPCONNECT: return tcp_connect(args->arg1, (struct sockaddr*)args->arg2); break; case TCPSEND: return tcp_send(args->arg1, (char *)args->arg2, args->arg3); break; case TCPRECV: return tcp_recv(args->arg1, (char *)args->arg2, args->arg3); break; case TCPSOCKET: return tcp_socket(); break; case TCPBIND: return tcp_bind(args->arg1, (struct sockaddr*)args->arg2); break; case TCPCLOSE: return tcp_close(args->arg1); break; case TCPLISTEN: return tcp_listen(args->arg1); break; } return 0; }
int tftp_udpclose(void * conn) { UDPCONN cn = (UDPCONN)conn; udp_close(cn); return 0; /* no ability to detect error on this API */ }
int main() { int fd = udp_init_broadcast(8887); char *sendtext = "UDP Test\n"; printf("Sending text:\n%s\n", sendtext); udp_send(fd, sendtext, strlen(sendtext)); udp_close(fd); return 0; }
int udp_bind_double ( udp_connection_t **_u1, udp_connection_t **_u2, int subsystem, const char *name1, const char *name2, const char *host, int port, const char *ifname, int rxsize1, int rxsize2, int txsize1, int txsize2 ) { udp_connection_t *u1 = NULL, *u2 = NULL; udp_connection_t *ucs[10]; int tst = 40, pos = 0, i, port2; memset(&ucs, 0, sizeof(ucs)); while (1) { u1 = udp_bind(subsystem, name1, host, port, NULL, ifname, rxsize1, txsize1); if (u1 == NULL || u1 == UDP_FATAL_ERROR) goto fail; port2 = ntohs(IP_PORT(u1->ip)); /* RTP port should be even, RTCP port should be odd */ if ((port2 % 2) == 0) { u2 = udp_bind(subsystem, name2, host, port2 + 1, NULL, ifname, rxsize2, txsize2); if (u2 != NULL && u2 != UDP_FATAL_ERROR) break; } if (tst) { udp_close(u1); tst--; continue; } ucs[pos++] = u1; if (port || pos >= ARRAY_SIZE(ucs)) goto fail; } for (i = 0; i < pos; i++) udp_close(ucs[i]); *_u1 = u1; *_u2 = u2; return 0; fail: for (i = 0; i < pos; i++) udp_close(ucs[i]); return -1; }
/* send to the gamecache that this browser does not anymore exist */ void ogc_shutdown () { if (ogc_sock <= 0) return; d_printf ("ogc_shutdown\n"); if (ogc_browsing) ogc_browsestop (); udp_close (ogc_sock); ogc_sock = -1; };
int main(void) { int server_fd; char buf[128]; struct sockaddr client; socklen_t client_len = sizeof(struct sockaddr); server_fd = udp_server("127.0.0.1", "21114"); udp_recvfrom(server_fd, buf, sizeof(buf), &client, &client_len); strcat(buf, " from server"); udp_sendto(server_fd, buf, sizeof(buf), &client, client_len); udp_close(server_fd); }
// ------------------------------------------------ // Function: dhcp_release_ip() // ------------------------------------------------ // Input: - // Output: TRUE if succesful // ------------------------------------------------ // Description: Release current dinamic IP // address // ------------------------------------------------ BOOL dhcp_release_ip(void) { BYTE i; if(ip_local[INTERFACE_ETH].d == 0) return TRUE; // no IP for releasing udp_close(SOCKET_DHCP); if(!udp_open(SOCKET_DHCP, UDP_DHCP_CLI, ip_dhcp, UDP_DHCP_SERV, INTERFACE_ETH)) return FALSE; for(i=0; i<3; i++) { if(!dhcp_envia(DHCPRELEASE, TRUE)) break; os_sleep(100); } udp_close(SOCKET_DHCP); ip_local[INTERFACE_ETH].d = 0; ip_gateway[INTERFACE_ETH].d = 0; ip_mask[INTERFACE_ETH].d = 0; ip_dhcp.d = 0xffffffff; return TRUE; }
// ------------------------------------------------ // Function: dhcp_get_ip() // ------------------------------------------------ // Input: - // Output: TRUE if succesful // ------------------------------------------------ // Description: Obtain a local IP address // using the DHCP protocol // ------------------------------------------------ BOOL dhcp_get_ip(void) { IPV4 ip; if(ip_local[INTERFACE_ETH].d) return TRUE; // already has an IP ip.d = 0xffffffff; udp_close(SOCKET_DHCP); if(!udp_open(SOCKET_DHCP, UDP_DHCP_CLI, ip, UDP_DHCP_SERV, INTERFACE_ETH)) return FALSE; ip_local[INTERFACE_ETH].d = 0; ip_tmp.d = 0; ip_dhcp.d = 0xffffffff; xid.b[0] = random(); xid.b[1] = random(); xid.b[2] = random(); xid.b[3] = random(); if(!dhcp_discover()) goto fail; // find a DHCP server udp_close(SOCKET_DHCP); if(!udp_open(SOCKET_DHCP, UDP_DHCP_CLI, ip, UDP_DHCP_SERV, INTERFACE_ETH)) return FALSE; if(!dhcp_req()) goto fail; // request an IP address ip_local[INTERFACE_ETH].d = ip_tmp.d; udp_close(SOCKET_DHCP); return TRUE; fail: ip_local[INTERFACE_ETH].d = 0; udp_close(SOCKET_DHCP); return FALSE; }
static void eap_wsc_reset(struct eap_sm *sm, void *priv) { wpa_printf(MSG_DEBUG, "EAP-WSC: Entered eap_wsc_reset"); struct eap_wsc_data *data = (struct eap_wsc_data *)priv; if (data == NULL) return; if (data->udpFdEap != -1) { udp_close(data->udpFdEap); data->udpFdEap = -1; } free(data); }
void send_test(void) { u32 ip = ((u32)192 << 24) | ((u32)168 << 16) | ((u32)1 << 8) | 20; u16 src_port; u16 port = 8888; char data[] = "hello world!"; u16 len; udp_close(0); if (udp_setup(ip, port, port) < 0) err_log("udp_setup"); send_data(ip, port, port, data, strlen(data)); recv_data(&ip, &src_port, data_i, &len); }
static void close_output( void *handle ) { struct ip_status *status = handle; if( status->output_params->output_opts.output == OUTPUT_RTP ) { if( *status->ip_handle ) rtp_close( *status->ip_handle ); } else { if( *status->ip_handle ) udp_close( *status->ip_handle ); } if( status->output_params->output_opts.target ) free( status->output_params->output_opts.target ); free( status->output_params ); }
/* shutdown the network part */ void network_shutdown () { int i; int new_server = bman.p_servnr; d_printf ("network_shutdown\n"); if (GT_MP_PTPM) { d_printf ("Server Quit Send information\n"); /* find new server */ for (i = 0; i < MAX_PLAYERS; i++) { if (PS_IS_used (players[i].state) && PS_IS_netplayer (players[i].state) && i != bman.p_servnr && players[i].net.flags == 0) new_server = i; } d_printf ("netword_shutdown: new server set to: %d\n", new_server); for (i = 0; i < MAX_PLAYERS; i++) if (i != bman.p_servnr && PS_IS_netplayer (players[i].state) && !PS_IS_aiplayer (players[i].state)) send_quit (&players[i].net.addr, bman.p_servnr, new_server); } else if (players[bman.p_servnr].net.addr.host[0] != 0) { send_quit (&players[bman.p_servnr].net.addr, bman.p_nr, bman.p_servnr); if (IS_LPLAYER2) send_quit (&players[bman.p_servnr].net.addr, bman.p2_nr, bman.p_servnr); } if (bman.notifygamemaster) { ogc_sendgamequit (bman.sock); ogc_shutdown (); } udp_close (bman.sock); bman.p_nr = -1; bman.sock = -1; #ifdef _WIN32 WSACleanup (); #endif };
// TODO make sure it is called on object destruction // Finish connection errno_t cn_udp_disconnect( struct data_area_4_connection *c ) { (void) c; SHOW_FLOW0( 1, "disconnect" ); struct cn_udp_volatile *vp = c->v_kernel_state; if( !(vp->udp_endpoint) ) return 0; #if HAVE_NET int rc = udp_close( vp->udp_endpoint ); if( rc ) #endif // HAVE_NET return EINVAL; return 0; }
int wsc_ie_deinit(struct hostapd_data *hapd) { #ifdef ACTION_TEC if (g_wsc_ie_data == NULL) return 0; #endif if (g_wsc_ie_data->udpFdCom != -1) { eloop_unregister_read_sock(g_wsc_ie_data->udpFdCom); udp_close(g_wsc_ie_data->udpFdCom); g_wsc_ie_data->udpFdCom = -1; } g_wsc_ie_data->hapd = NULL; free(g_wsc_ie_data); g_wsc_ie_data = NULL; return 0; }
uint8_t dhcp_get_ip() { uint8_t sockid = SOCKET_INVALID; // First get a socket sockid = udp_open(DHCP_CLIENT_PORT); if (sockid == SOCKET_INVALID) return 1; dhcp_send_packet(sockid, DHCP_DISCOVER); if (dhcp_read_packet(sockid) != DHCP_OFFER) return 2; dhcp_send_packet(sockid, DHCP_REQUEST); if (dhcp_read_packet(sockid) != DHCP_ACK) return 3; // Finally close the socket udp_close(sockid); return 0; }
int url_close(URL *url) { if(NULL == url) { printf("Bad parameter!\n"); return -1; } switch(url->protocol) { case PRTCL_UDP: udp_close(url->udp, url->ip); break; default: // PRTCL_FILE fclose(url->fd); break; } free(url); return 0; }
int net_Close(TNetWork *_ptNetWork) { TNetWorkMsg *ptNetWorkMsg = (TNetWorkMsg *)_ptNetWork; if(NULL == ptNetWorkMsg) { dbg(); return ERR; } LockMx(ptNetWorkMsg->m_SendMux); if(NET_TYPE_TCP == ptNetWorkMsg->m_iType) { tcp_close(ptNetWorkMsg->m_iSocket); } else { udp_close(ptNetWorkMsg->m_iSocket); } UnLockMx(ptNetWorkMsg->m_SendMux); ptNetWorkMsg->m_iSocket = INVALID_SOCKET; return OK; }
udp_connection_t * udp_sendinit ( int subsystem, const char *name, const char *ifname, int txsize ) { int fd, ifindex; udp_connection_t *uc; uc = calloc(1, sizeof(udp_connection_t)); uc->fd = -1; uc->ifname = ifname ? strdup(ifname) : NULL; uc->subsystem = subsystem; uc->name = name ? strdup(name) : NULL; uc->rxtxsize = txsize; /* Open socket */ if ((fd = tvh_socket(uc->ip.ss_family, SOCK_DGRAM, 0)) == -1) { tvherror(subsystem, "%s - failed to create socket [%s]", name, strerror(errno)); udp_close(uc); return UDP_FATAL_ERROR; } uc->fd = fd; /* Bind to interface */ ifindex = udp_ifindex_required(uc) ? udp_get_ifindex(ifname) : 0; if (ifindex < 0) { tvherror(subsystem, "%s - could not find interface %s", name, ifname); goto error; } if (uc->multicast) { if (uc->ip.ss_family == AF_INET) { #if !defined(PLATFORM_DARWIN) struct ip_mreqn m; memset(&m, 0, sizeof(m)); m.imr_ifindex = ifindex; #else struct in_addr m; if (udp_get_ifaddr(fd, ifname, &m) == -1) { tvherror(subsystem, "%s - cannot find ip address for interface %s [e=%s]", name, ifname, strerror(errno)); goto error; } #endif if (setsockopt(fd, udp_get_solip(), IP_MULTICAST_IF, &m, sizeof(m))) tvhwarn(subsystem, "%s - cannot set source interface %s [%s]", name, ifname, strerror(errno)); } else { struct ipv6_mreq m; memset(&m, 0, sizeof(m)); m.ipv6mr_interface = ifindex; #ifdef SOL_IPV6 if (setsockopt(fd, SOL_IPV6, IPV6_MULTICAST_IF, &m, sizeof(m))) { tvhwarn(subsystem, "%s - cannot set source interface %s [%s]", name, ifname, strerror(errno)); } #else tvherror(subsystem, "IPv6 multicast not supported"); goto error; #endif } } /* Increase TX buffer size */ if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &txsize, sizeof(txsize)) == -1) tvhwarn(subsystem, "%s - cannot increase UDP tx buffer size [%s]", name, strerror(errno)); return uc; error: udp_close(uc); return NULL; }
/* * Discovery thread */ static void * upnp_thread( void *aux ) { char *bindaddr = aux; tvhpoll_t *poll = tvhpoll_create(2); tvhpoll_event_t ev[2]; upnp_data_t *data; udp_connection_t *multicast = NULL, *unicast = NULL; udp_connection_t *conn; unsigned char buf[16384]; upnp_service_t *us; struct sockaddr_storage ip; socklen_t iplen; size_t size; int r, delay_ms; multicast = udp_bind(LS_UPNP, "upnp_thread_multicast", "239.255.255.250", 1900, NULL, NULL, 32*1024, 32*1024); if (multicast == NULL || multicast == UDP_FATAL_ERROR) goto error; unicast = udp_bind(LS_UPNP, "upnp_thread_unicast", bindaddr, 0, NULL, NULL, 32*1024, 32*1024); if (unicast == NULL || unicast == UDP_FATAL_ERROR) goto error; memset(&ev, 0, sizeof(ev)); ev[0].fd = multicast->fd; ev[0].events = TVHPOLL_IN; ev[0].ptr = multicast; ev[1].fd = unicast->fd; ev[1].events = TVHPOLL_IN; ev[1].ptr = unicast; tvhpoll_add(poll, ev, 2); delay_ms = 0; while (atomic_get(&upnp_running) && multicast->fd >= 0) { r = tvhpoll_wait(poll, ev, 2, delay_ms ?: 1000); if (r == 0) /* timeout */ delay_ms = 0; while (r-- > 0) { if ((ev[r].events & TVHPOLL_IN) != 0) { conn = ev[r].ptr; iplen = sizeof(ip); size = recvfrom(conn->fd, buf, sizeof(buf), 0, (struct sockaddr *)&ip, &iplen); if (size > 0 && tvhtrace_enabled()) { char tbuf[256]; inet_ntop(ip.ss_family, IP_IN_ADDR(ip), tbuf, sizeof(tbuf)); tvhtrace(LS_UPNP, "%s - received data from %s:%hu [size=%zi]", conn == multicast ? "multicast" : "unicast", tbuf, (unsigned short) ntohs(IP_PORT(ip)), size); tvhlog_hexdump(LS_UPNP, buf, size); } /* TODO: a filter */ TAILQ_FOREACH(us, &upnp_services, us_link) us->us_received(buf, size, conn, &ip); } } while (delay_ms == 0) { tvh_mutex_lock(&upnp_lock); data = TAILQ_FIRST(&upnp_data_write); if (data) { delay_ms = data->delay_ms; data->delay_ms = 0; if (!delay_ms) { TAILQ_REMOVE(&upnp_data_write, data, data_link); } else { data = NULL; } } tvh_mutex_unlock(&upnp_lock); if (data == NULL) break; upnp_dump_data(data); udp_write_queue(data->from_multicast ? multicast : unicast, &data->queue, &data->storage); htsbuf_queue_flush(&data->queue); free(data); delay_ms = 0; } } /* flush the write queue (byebye messages) */ while (1) { tvh_mutex_lock(&upnp_lock); data = TAILQ_FIRST(&upnp_data_write); if (data) TAILQ_REMOVE(&upnp_data_write, data, data_link); tvh_mutex_unlock(&upnp_lock); if (data == NULL) break; tvh_safe_usleep((long)data->delay_ms * 1000); upnp_dump_data(data); udp_write_queue(unicast, &data->queue, &data->storage); htsbuf_queue_flush(&data->queue); free(data); } error: atomic_set(&upnp_running, 0); tvhpoll_destroy(poll); udp_close(unicast); udp_close(multicast); return NULL; }
udp_connection_t * udp_bind ( int subsystem, const char *name, const char *bindaddr, int port, const char *multicast_src, const char *ifname, int rxsize, int txsize ) { int fd, ifindex, reuse = 1; udp_connection_t *uc; char buf[256]; socklen_t addrlen; uc = calloc(1, sizeof(udp_connection_t)); uc->fd = -1; uc->host = bindaddr ? strdup(bindaddr) : NULL; uc->port = port; uc->ifname = ifname ? strdup(ifname) : NULL; uc->subsystem = subsystem; uc->name = name ? strdup(name) : NULL; uc->rxtxsize = rxsize; if (udp_resolve(uc, &uc->ip, uc->host, port, &uc->multicast, 1)) { udp_close(uc); return UDP_FATAL_ERROR; } /* Open socket */ if ((fd = tvh_socket(uc->ip.ss_family, SOCK_DGRAM, 0)) == -1) { tvherror(subsystem, "%s - failed to create socket [%s]", name, strerror(errno)); udp_close(uc); return UDP_FATAL_ERROR; } uc->fd = fd; /* Mark reuse address */ if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse))) { tvherror(subsystem, "%s - failed to reuse address for socket [%s]", name, strerror(errno)); udp_close(uc); return UDP_FATAL_ERROR; } /* Bind to interface */ ifindex = udp_ifindex_required(uc) ? udp_get_ifindex(ifname) : 0; if (ifindex < 0) { tvherror(subsystem, "%s - could not find interface %s", name, ifname); goto error; } /* IPv4 */ if (uc->ip.ss_family == AF_INET) { /* Bind */ if (bind(fd, (struct sockaddr *)&uc->ip, sizeof(struct sockaddr_in))) { inet_ntop(AF_INET, &IP_AS_V4(uc->ip, addr), buf, sizeof(buf)); tvherror(subsystem, "%s - cannot bind %s:%hu [e=%s]", name, buf, ntohs(IP_AS_V4(uc->ip, port)), strerror(errno)); goto error; } if (uc->multicast) { /* Join multicast group */ if (multicast_src && *multicast_src) { /* Join with specific source address (SSM) */ struct ip_mreq_source ms; memset(&ms, 0, sizeof(ms)); ms.imr_multiaddr = IP_AS_V4(uc->ip, addr); /* Note, ip_mreq_source does not support the ifindex parameter, so we have to resolve to the ip of the interface on all platforms. */ if (udp_get_ifaddr(fd, ifname, &ms.imr_interface) == -1) { tvherror(subsystem, "%s - cannot find ip address for interface %s [e=%s]", name, ifname, strerror(errno)); goto error; } if (inet_pton(AF_INET, multicast_src, &ms.imr_sourceaddr) < 1) { tvherror(subsystem, "%s - invalid ipv4 address '%s' specified as multicast source [e=%s]", name, multicast_src, strerror(errno)); goto error; } if (setsockopt(fd, udp_get_solip(), IP_ADD_SOURCE_MEMBERSHIP, &ms, sizeof(ms)) < 0) { tvherror(subsystem, "%s - setsockopt IP_ADD_SOURCE_MEMBERSHIP failed [e=%s]", name, strerror(errno)); goto error; } } else { /* Standard multicast join (non-SSM) */ #if defined(PLATFORM_DARWIN) struct ip_mreq m; #else struct ip_mreqn m; #endif memset(&m, 0, sizeof(m)); m.imr_multiaddr = IP_AS_V4(uc->ip, addr); #if !defined(PLATFORM_DARWIN) m.imr_address.s_addr = 0; m.imr_ifindex = ifindex; #else if (udp_get_ifaddr(fd, ifname, &m.imr_interface) == -1) { tvherror(subsystem, "%s - cannot find ip address for interface %s [e=%s]", name, ifname, strerror(errno)); goto error; } #endif if (setsockopt(fd, udp_get_solip(), IP_ADD_MEMBERSHIP, &m, sizeof(m))) { inet_ntop(AF_INET, &m.imr_multiaddr, buf, sizeof(buf)); tvhwarn(subsystem, "%s - cannot join %s [%s]", name, buf, strerror(errno)); } } } /* Bind to IPv6 group */ } else { struct ipv6_mreq m; memset(&m, 0, sizeof(m)); /* Bind */ if (bind(fd, (struct sockaddr *)&uc->ip, sizeof(struct sockaddr_in6))) { inet_ntop(AF_INET6, &IP_AS_V6(uc->ip, addr), buf, sizeof(buf)); tvherror(subsystem, "%s - cannot bind %s:%hu [e=%s]", name, buf, ntohs(IP_AS_V6(uc->ip, port)), strerror(errno)); goto error; } if (uc->multicast) { /* Join group */ m.ipv6mr_multiaddr = IP_AS_V6(uc->ip, addr); m.ipv6mr_interface = ifindex; #ifdef SOL_IPV6 if (setsockopt(fd, SOL_IPV6, IPV6_ADD_MEMBERSHIP, &m, sizeof(m))) { inet_ntop(AF_INET, &m.ipv6mr_multiaddr, buf, sizeof(buf)); tvhwarn(subsystem, "%s - cannot join %s [%s]", name, buf, strerror(errno)); } #else tvherror(subsystem, "IPv6 multicast not supported"); goto error; #endif } } addrlen = sizeof(uc->ip); if (getsockname(fd, (struct sockaddr *)&uc->ip, &addrlen)) { tvherror(subsystem, "%s - cannot obtain socket name [%s]", name, strerror(errno)); goto error; } /* Increase/Decrease RX buffer size */ if (rxsize > 0 && setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rxsize, sizeof(rxsize)) == -1) tvhwarn(subsystem, "%s - cannot change UDP rx buffer size [%s]", name, strerror(errno)); /* Increase/Decrease TX buffer size */ if (txsize > 0 && setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &txsize, sizeof(txsize)) == -1) tvhwarn(subsystem, "%s - cannot change UDP tx buffer size [%s]", name, strerror(errno)); return uc; error: udp_close(uc); return NULL; }
int main (void) { int ret, sd, ii; gnutls_session_t session; char buffer[MAX_BUF + 1]; const char *err; gnutls_certificate_credentials_t xcred; gnutls_global_init (); /* X509 stuff */ gnutls_certificate_allocate_credentials (&xcred); /* sets the trusted cas file */ gnutls_certificate_set_x509_trust_file (xcred, CAFILE, GNUTLS_X509_FMT_PEM); /* Initialize TLS session */ gnutls_init (&session, GNUTLS_CLIENT|GNUTLS_DATAGRAM); /* Use default priorities */ ret = gnutls_priority_set_direct (session, "NORMAL", &err); if (ret < 0) { if (ret == GNUTLS_E_INVALID_REQUEST) { fprintf (stderr, "Syntax error at: %s\n", err); } exit (1); } /* put the x509 credentials to the current session */ gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); /* connect to the peer */ sd = udp_connect (); gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd); /* set the connection MTU */ gnutls_dtls_set_mtu (session, 1000); /* Perform the TLS handshake */ ret = gnutls_handshake (session); if (ret < 0) { fprintf (stderr, "*** Handshake failed\n"); gnutls_perror (ret); goto end; } else { printf ("- Handshake was completed\n"); } gnutls_record_send (session, MSG, strlen (MSG)); ret = gnutls_record_recv (session, buffer, MAX_BUF); if (ret == 0) { printf ("- Peer has closed the TLS connection\n"); goto end; } else if (ret < 0) { fprintf (stderr, "*** Error: %s\n", gnutls_strerror (ret)); goto end; } printf ("- Received %d bytes: ", ret); for (ii = 0; ii < ret; ii++) { fputc (buffer[ii], stdout); } fputs ("\n", stdout); /* It is suggested not to use GNUTLS_SHUT_RDWR in DTLS * connections because the peer's closure message might * be lost */ gnutls_bye (session, GNUTLS_SHUT_WR); end: udp_close (sd); gnutls_deinit (session); gnutls_certificate_free_credentials (xcred); gnutls_global_deinit (); return 0; }
int main(void) { int ret, sd, ii; gnutls_session_t session; char buffer[MAX_BUF + 1]; const char *err; gnutls_certificate_credentials_t xcred; if (gnutls_check_version("3.1.4") == NULL) { fprintf(stderr, "GnuTLS 3.1.4 or later is required for this example\n"); exit(1); } /* for backwards compatibility with gnutls < 3.3.0 */ gnutls_global_init(); /* X509 stuff */ gnutls_certificate_allocate_credentials(&xcred); /* sets the trusted cas file */ gnutls_certificate_set_x509_trust_file(xcred, CAFILE, GNUTLS_X509_FMT_PEM); gnutls_certificate_set_verify_function(xcred, verify_certificate_callback); /* Initialize TLS session */ gnutls_init(&session, GNUTLS_CLIENT | GNUTLS_DATAGRAM); /* Use default priorities */ ret = gnutls_priority_set_direct(session, "NORMAL", &err); if (ret < 0) { if (ret == GNUTLS_E_INVALID_REQUEST) { fprintf(stderr, "Syntax error at: %s\n", err); } exit(1); } /* put the x509 credentials to the current session */ gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, xcred); gnutls_server_name_set(session, GNUTLS_NAME_DNS, "my_host_name", strlen("my_host_name")); /* connect to the peer */ sd = udp_connect(); gnutls_transport_set_int(session, sd); /* set the connection MTU */ gnutls_dtls_set_mtu(session, 1000); gnutls_handshake_set_timeout(session, GNUTLS_DEFAULT_HANDSHAKE_TIMEOUT); /* Perform the TLS handshake */ do { ret = gnutls_handshake(session); } while (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN); /* Note that DTLS may also receive GNUTLS_E_LARGE_PACKET */ if (ret < 0) { fprintf(stderr, "*** Handshake failed\n"); gnutls_perror(ret); goto end; } else { char *desc; desc = gnutls_session_get_desc(session); printf("- Session info: %s\n", desc); gnutls_free(desc); } gnutls_record_send(session, MSG, strlen(MSG)); ret = gnutls_record_recv(session, buffer, MAX_BUF); if (ret == 0) { printf("- Peer has closed the TLS connection\n"); goto end; } else if (ret < 0 && gnutls_error_is_fatal(ret) == 0) { fprintf(stderr, "*** Warning: %s\n", gnutls_strerror(ret)); } else if (ret < 0) { fprintf(stderr, "*** Error: %s\n", gnutls_strerror(ret)); goto end; } if (ret > 0) { printf("- Received %d bytes: ", ret); for (ii = 0; ii < ret; ii++) { fputc(buffer[ii], stdout); } fputs("\n", stdout); } /* It is suggested not to use GNUTLS_SHUT_RDWR in DTLS * connections because the peer's closure message might * be lost */ gnutls_bye(session, GNUTLS_SHUT_WR); end: udp_close(sd); gnutls_deinit(session); gnutls_certificate_free_credentials(xcred); gnutls_global_deinit(); return 0; }