static int bind_src_by_address(int sockfd, char *address)
{
int rc = 0;
char port[NI_MAXSERV];
struct sockaddr_storage saddr;
memset(&saddr, 0, sizeof(struct sockaddr_storage));
if (resolve_address(address, port, &saddr)) {
log_error("Could not bind %s to conn.", address);
return -1;
}
switch (saddr.ss_family) {
case AF_INET:
rc = bind(sockfd, (struct sockaddr *)&saddr,
sizeof(struct sockaddr_in));
break;
case AF_INET6:
rc = bind(sockfd, (struct sockaddr *)&saddr,
sizeof(struct sockaddr_in6));
break;
default:
rc = -1;
}
if (rc)
log_error("Could not bind %s to %d.", address, sockfd);
else
log_debug(4, "Bound %s to socket fd %d", address, sockfd);
return rc;
}
/**
* Function to call with a binary address
*
* @param cls closure
* @param peer identity of the peer
* @param address binary address (NULL on disconnect)
*/
static void
process_address (void *cls, const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HELLO_Address *address)
{
if (peer == NULL)
{
/* done */
address_resolution_in_progress = GNUNET_NO;
pic = NULL;
if (GNUNET_SCHEDULER_NO_TASK != end)
GNUNET_SCHEDULER_cancel (end);
end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
return;
}
if (address == NULL)
{
FPRINTF (stdout, _("Peer `%s' disconnected\n"), GNUNET_i2s (peer));
return;
}
if (GNUNET_SCHEDULER_NO_TASK != op_timeout)
GNUNET_SCHEDULER_cancel (op_timeout);
op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT,
&operation_timeout, NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received address for peer `%s': %s\n",
GNUNET_i2s (peer), address->transport_name);
resolve_address (address, numeric);
}
const char *format_host(int af, int len, const void *addr,
char *buf, int buflen)
{
#ifdef RESOLVE_HOSTNAMES
if (resolve_hosts) {
const char *n;
if (len <= 0) {
switch (af) {
case AF_INET:
len = 4;
break;
case AF_INET6:
len = 16;
break;
case AF_IPX:
len = 10;
break;
#ifdef AF_DECnet
/* I see no reasons why gethostbyname
may not work for DECnet */
case AF_DECnet:
len = 2;
break;
#endif
default: ;
}
}
if (len > 0 &&
(n = resolve_address(addr, len, af)) != NULL)
return n;
}
#endif
return rt_addr_n2a(af, len, addr, buf, buflen);
}
resource_address resource_system::resolve_address_to_directory(
const char* resource_type_name,
const char* folder,
const char* id,
const char* id_source_description) {
return resolve_address(false, resource_type_name, folder, "", id, id_source_description);
}
resource_address resource_system::resolve_address_to_file(
const char* resource_type_name,
const char* folder,
const char* extensions,
const char* id,
const char* id_source_description) {
return resolve_address(true, resource_type_name, folder, extensions, id, id_source_description);
}
static int source_address()
{
if(resolve_address(source_str, &source, NULL) == 0)
{
return 0;
}
return 1;
}
void test_labels(void) {
init_hash_table();
Instruction* i = new_instruction_label("test", 1);
TEST_ASSERT_EQUAL_STRING("test", i->opcode);
TEST_ASSERT(i->type = I_TYPE_LABEL);
set_label_address("test", 34);
Address* a = addr_from_label(strdup("test"));
resolve_address(a);
TEST_ASSERT_EQUAL_INT_MESSAGE(34, a->immediate, "Incorrect label address");
free(a);
free(i);
}
/* [DEM monitoring] gets adapter request URL */
char* dem_get_adapter_request(context_t* context, char* name, char* args, const char* type, int nrpe)
{
char buffer[MAXBUFLEN];
char* result = NULL;
option_list_t opts = NULL;
/* Take adapter query fields from plugin arguments, distinguishing
between local executions (host_addr as identifier) and NRPE plugin
executions (-H plugin argument as identifier) */
if (!nrpe) {
char* addr = host_addr;
snprintf(buffer, sizeof(buffer)-1, DEM_ADAPTER_REQUEST_FORMAT,
adapter_url, name, region_id, addr, type);
buffer[sizeof(buffer)-1] = '\0';
result = strdup(buffer);
} else if ((opts = parse_args(args, ":H:nup:t:c:a:")) == NULL) {
logging(LOG_WARN, context, "Cannot get NRPE plugin options");
result = ADAPTER_REQUEST_INVALID;
} else {
char addr[INET_ADDRSTRLEN];
const char* host = NULL;
size_t i;
for (i = 0; opts[i].opt != -1; i++) {
switch(opts[i].opt) {
case 'H': {
host = opts[i].val;
break;
}
}
}
if (host == NULL) {
logging(LOG_WARN, context, "Missing NRPE plugin options");
result = ADAPTER_REQUEST_INVALID;
} else if (resolve_address(host, addr, INET_ADDRSTRLEN) == NEB_ERROR) {
logging(LOG_WARN, context, "Cannot resolve remote address for %s", host);
result = ADAPTER_REQUEST_INVALID;
} else {
snprintf(buffer, sizeof(buffer)-1, DEM_ADAPTER_REQUEST_FORMAT,
adapter_url, name, region_id, addr, type);
buffer[sizeof(buffer)-1] = '\0';
result = strdup(buffer);
}
}
free_option_list(opts);
opts = NULL;
return result;
}
const char *format_host(int af, int len, const void *addr,
char *buf, int buflen)
{
#ifdef RESOLVE_HOSTNAMES
if (resolve_hosts) {
const char *n;
len = len <= 0 ? af_byte_len(af) : len;
if (len > 0 &&
(n = resolve_address(addr, len, af)) != NULL)
return n;
}
#endif
return rt_addr_n2a(af, len, addr, buf, buflen);
}
void NetworkConnector::do_connect(const std::string &address,
uint16_t port)
{
std::vector<uvw::Addr> addresses = resolve_address(address, port, m_loop);
if(addresses.size() == 0) {
if(m_connect_callback != nullptr)
m_connect_callback(nullptr);
return;
}
for(auto it = addresses.begin(); it != addresses.end(); ++it) {
m_socket->connect(*it);
}
}
static socklen_t wsck_resolve(const char *str, mrp_sockaddr_t *addr,
socklen_t size, const char **typep)
{
mrp_wsckaddr_t *wa = (mrp_wsckaddr_t *)addr;
socklen_t len;
len = resolve_address(str, wa, size);
if (len <= 0)
return 0;
else {
if (typep != NULL)
*typep = WSCKP;
return len;
}
}
static void
process_string (void *cls, const char *address)
{
struct ResolutionContext *rc = cls;
struct GNUNET_HELLO_Address *addrcp = rc->addrcp;
if (address != NULL)
{
FPRINTF (stdout, _("Peer `%s': %s %s\n"), GNUNET_i2s (&addrcp->peer), addrcp->transport_name, address);
rc->printed = GNUNET_YES;
}
else
{
/* done */
GNUNET_assert (address_resolutions > 0);
address_resolutions --;
if (GNUNET_NO == rc->printed)
{
if (numeric == GNUNET_NO)
{
resolve_address (rc->addrcp, GNUNET_YES ); /* Failed to resolve address, try numeric lookup */
}
else
FPRINTF (stdout, _("Peer `%s': %s <unable to resolve address>\n"), GNUNET_i2s (&addrcp->peer), addrcp->transport_name);
}
GNUNET_free (rc->addrcp);
GNUNET_CONTAINER_DLL_remove (rc_head, rc_tail, rc);
GNUNET_free (rc);
if ((0 == address_resolutions) && (iterate_connections))
{
if (GNUNET_SCHEDULER_NO_TASK != end)
{
GNUNET_SCHEDULER_cancel (end);
end = GNUNET_SCHEDULER_NO_TASK;
}
if (GNUNET_SCHEDULER_NO_TASK != op_timeout)
{
GNUNET_SCHEDULER_cancel (op_timeout);
op_timeout = GNUNET_SCHEDULER_NO_TASK;
}
ret = 0;
end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
}
}
}
static struct host_entry *add_host_entry(char *target, struct host_entry *cur)
{
struct host_entry *host_entry;
static int number = 0;
struct sockaddr *addr;
char *canonname;
if(target == NULL)
{
return NULL;
}
if(resolve_address(target, &addr, &canonname) == 0)
{
return NULL;
}
host_entry = malloc(sizeof(struct host_entry));
if(host_entry == NULL)
{
return NULL;
}
host_entry->name = strdup(target);
host_entry->i = number; number++;
host_entry->dns_name = canonname;
host_entry->addr = addr;
host_entry->rx = 0;
host_entry->tx = 0;
host_entry->next = NULL;
/*
* if we have resolved a DNS name associated with the IP address we print
* that. otherwise, we identify this host entry (to the user) with the
* ip address supplied
*/
if(host_entry->dns_name != NULL) host_entry->printed = host_entry->dns_name;
else host_entry->printed = host_entry->name;
/* merge this item into the linked list ... */
if(cur != NULL) cur->next = host_entry;
else head = host_entry;
return host_entry;
}
int main( int argc, char *argv[] )
{
int ip;
char *address;
if( argc != 2 )
{
printf( "unknown.host\r\n" );
exit( 0 );
}
ip = atoi( argv[1] );
address = resolve_address( ip );
printf( "%s\r\n", address );
exit( 0 );
}
int connect_to_tcpr(void)
{
char *tmp;
char *host;
char *port;
struct sockaddr_in addr;
int s;
int err;
tmp = getenv("TCPR_HOST");
if (!tmp)
return -1;
host = strdup(tmp);
if (!host)
return -1;
tmp = getenv("TCPR_PORT");
if (!tmp) {
free(host);
return -1;
}
port = strdup(tmp);
if (!port) {
free(host);
return -1;
}
err = resolve_address(&addr, host, port);
free(host);
free(port);
if (err)
return -1;
s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (s < 0)
return -1;
if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
close(s);
return -1;
}
return s;
}
void EventLogger::bind(const std::string &addr)
{
// We have to make sure our bind happens within the context of the main thread.
assert(std::this_thread::get_id() == g_main_thread_id);
m_log.info() << "Opening UDP socket..." << std::endl;
auto addresses = resolve_address(addr, 7197, g_loop);
if(addresses.size() == 0) {
m_log.fatal() << "Failed to bind to EventLogger address " << addr << "\n";
exit(1);
}
m_local = addresses.front();
m_socket = g_loop->resource<uvw::UDPHandle>();
m_socket->bind(m_local);
start_receive();
}
int client_create(Client *client, EventHandle socket,
struct sockaddr_in *address, socklen_t length) {
log_debug("Creating client from socket (handle: %d)", socket);
client->socket = socket;
client->packet_used = 0;
// create pending request array
if (array_create(&client->pending_requests, 32,
sizeof(PacketHeader), 1) < 0) {
log_error("Could not create pending request array: %s (%d)",
get_errno_name(errno), errno);
return -1;
}
// get peer name
client->peer = resolve_address(address, length);
if (client->peer == NULL) {
log_warn("Could not get peer name of client (socket: %d): %s (%d)",
socket, get_errno_name(errno), errno);
client->peer = (char *)_unknown_peer_name;
}
// add socket as event source
if (event_add_source(client->socket, EVENT_SOURCE_TYPE_GENERIC, EVENT_READ,
client_handle_receive, client) < 0) {
if (client->peer != _unknown_peer_name) {
free(client->peer);
}
array_destroy(&client->pending_requests, NULL);
return -1;
}
return 0;
}
void main( int argc, char *argv[] )
{
sh_int local, remote;
int ip;
char *address, *user;
if ( argc!=4 )
{
printf( "unknown.host\n\r" );
exit( 0 );
}
local = atoi( argv[1] );
ip = atoi( argv[2] );
remote = atoi( argv[3] );
address=resolve_address( ip );
user=resolve_username( ip, local, remote );
printf( "%s %s\n\r", address, user );
exit( 0 );
}
int
main(int argc, char **argv) {
dtls_context_t *dtls_context = NULL;
fd_set rfds, wfds;
struct timeval timeout;
unsigned short port = DEFAULT_PORT;
char port_str[NI_MAXSERV] = "0";
log_t log_level = LOG_WARN;
int fd, result;
int on = 1;
int opt, res;
session_t dst;
dtls_init();
snprintf(port_str, sizeof(port_str), "%d", port);
while ((opt = getopt(argc, argv, "p:o:v:")) != -1) {
switch (opt) {
case 'p' :
strncpy(port_str, optarg, NI_MAXSERV-1);
port_str[NI_MAXSERV - 1] = '\0';
break;
case 'o' :
output_file.length = strlen(optarg);
output_file.s = (unsigned char *)malloc(output_file.length + 1);
if (!output_file.s) {
dsrv_log(LOG_CRIT, "cannot set output file: insufficient memory\n");
exit(-1);
} else {
/* copy filename including trailing zero */
memcpy(output_file.s, optarg, output_file.length + 1);
}
break;
case 'v' :
log_level = strtol(optarg, NULL, 10);
break;
default:
usage(argv[0], PACKAGE_VERSION);
exit(1);
}
}
set_log_level(log_level);
if (argc <= optind) {
usage(argv[0], PACKAGE_VERSION);
exit(1);
}
memset(&dst, 0, sizeof(session_t));
/* resolve destination address where server should be sent */
res = resolve_address(argv[optind++], &dst.addr.sa);
if (res < 0) {
dsrv_log(LOG_EMERG, "failed to resolve address\n");
exit(-1);
}
dst.size = res;
/* use port number from command line when specified or the listen
port, otherwise */
dst.addr.sin.sin_port = htons(atoi(optind < argc ? argv[optind++] : port_str));
/* init socket and set it to non-blocking */
fd = socket(dst.addr.sa.sa_family, SOCK_DGRAM, 0);
if (fd < 0) {
dsrv_log(LOG_ALERT, "socket: %s\n", strerror(errno));
return 0;
}
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) ) < 0) {
dsrv_log(LOG_ALERT, "setsockopt SO_REUSEADDR: %s\n", strerror(errno));
}
#if 0
flags = fcntl(fd, F_GETFL, 0);
if (flags < 0 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
dsrv_log(LOG_ALERT, "fcntl: %s\n", strerror(errno));
goto error;
}
#endif
on = 1;
#ifdef IPV6_RECVPKTINFO
if (setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on, sizeof(on) ) < 0) {
#else /* IPV6_RECVPKTINFO */
if (setsockopt(fd, IPPROTO_IPV6, IPV6_PKTINFO, &on, sizeof(on) ) < 0) {
#endif /* IPV6_RECVPKTINFO */
dsrv_log(LOG_ALERT, "setsockopt IPV6_PKTINFO: %s\n", strerror(errno));
}
dtls_context = dtls_new_context(&fd);
if (!dtls_context) {
dsrv_log(LOG_EMERG, "cannot create context\n");
exit(-1);
}
dtls_set_handler(dtls_context, &cb);
dtls_connect(dtls_context, &dst);
while (1) {
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_SET(fileno(stdin), &rfds);
FD_SET(fd, &rfds);
/* FD_SET(fd, &wfds); */
timeout.tv_sec = 5;
timeout.tv_usec = 0;
result = select(fd+1, &rfds, &wfds, 0, &timeout);
if (result < 0) { /* error */
if (errno != EINTR)
perror("select");
} else if (result == 0) { /* timeout */
} else { /* ok */
if (FD_ISSET(fd, &wfds))
/* FIXME */;
else if (FD_ISSET(fd, &rfds))
dtls_handle_read(dtls_context);
else if (FD_ISSET(fileno(stdin), &rfds))
handle_stdin();
}
if (len)
try_send(dtls_context, &dst);
}
dtls_free_context(dtls_context);
exit(0);
}
static BOOL send_udp_multicast_of_type(const char *data, int length, ULONG family)
{
IP_ADAPTER_ADDRESSES *adapter_addresses = NULL, *adapter_addr;
static const struct in6_addr i_addr_zero;
struct addrinfo *multi_address;
ULONG bufferSize = 0;
LPSOCKADDR sockaddr;
BOOL ret = FALSE;
const char ttl = 8;
ULONG retval;
SOCKET s;
/* Resolve the multicast address */
if (family == AF_INET6)
multi_address = resolve_address(SEND_ADDRESS_IPV6, SEND_PORT, AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
else
multi_address = resolve_address(SEND_ADDRESS_IPV4, SEND_PORT, AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (multi_address == NULL)
return FALSE;
/* Get size of buffer for adapters */
retval = GetAdaptersAddresses(family, 0, NULL, NULL, &bufferSize);
if (retval != ERROR_BUFFER_OVERFLOW) goto cleanup;
adapter_addresses = (IP_ADAPTER_ADDRESSES *) heap_alloc(bufferSize);
if (adapter_addresses == NULL) goto cleanup;
/* Get list of adapters */
retval = GetAdaptersAddresses(family, 0, NULL, adapter_addresses, &bufferSize);
if (retval != ERROR_SUCCESS) goto cleanup;
for (adapter_addr = adapter_addresses; adapter_addr != NULL; adapter_addr = adapter_addr->Next)
{
if (adapter_addr->FirstUnicastAddress == NULL) continue;
sockaddr = adapter_addr->FirstUnicastAddress->Address.lpSockaddr;
/* Create a socket and bind to the adapter address */
s = socket(family, SOCK_DGRAM, IPPROTO_UDP);
if (s == INVALID_SOCKET) continue;
if (bind(s, sockaddr, adapter_addr->FirstUnicastAddress->Address.iSockaddrLength) == SOCKET_ERROR)
{
closesocket(s);
continue;
}
/* Set the multicast interface and TTL value */
setsockopt(s, IPPROTO_IP, IP_MULTICAST_IF, (char *) &i_addr_zero,
(family == AF_INET6) ? sizeof(struct in6_addr) : sizeof(struct in_addr));
setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl));
sendto(s, data, length, 0, (SOCKADDR *) multi_address->ai_addr, multi_address->ai_addrlen);
closesocket(s);
}
ret = TRUE;
cleanup:
freeaddrinfo(multi_address);
heap_free(adapter_addresses);
return ret;
}
static void start_listening(messageStorage *msgStorage, const char *multicastAddress, const char *bindAddress)
{
struct addrinfo *multicastAddr = NULL, *bindAddr = NULL, *interfaceAddr = NULL;
listenerThreadParams *parameter = NULL;
const DWORD receiveTimeout = 500;
const UINT reuseAddr = 1;
HANDLE hThread;
SOCKET s = 0;
/* Resolve the multicast address */
multicastAddr = resolve_address(multicastAddress, SEND_PORT, AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP);
if (multicastAddr == NULL) goto cleanup;
/* Resolve the binding address */
bindAddr = resolve_address(bindAddress, SEND_PORT, multicastAddr->ai_family, multicastAddr->ai_socktype, multicastAddr->ai_protocol);
if (bindAddr == NULL) goto cleanup;
/* Resolve the multicast interface */
interfaceAddr = resolve_address(bindAddress, "0", multicastAddr->ai_family, multicastAddr->ai_socktype, multicastAddr->ai_protocol);
if (interfaceAddr == NULL) goto cleanup;
/* Create the socket */
s = socket(multicastAddr->ai_family, multicastAddr->ai_socktype, multicastAddr->ai_protocol);
if (s == INVALID_SOCKET) goto cleanup;
/* Ensure the socket can be reused */
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuseAddr, sizeof(reuseAddr)) == SOCKET_ERROR) goto cleanup;
/* Bind the socket to the local interface so we can receive data */
if (bind(s, bindAddr->ai_addr, bindAddr->ai_addrlen) == SOCKET_ERROR) goto cleanup;
/* Join the multicast group */
if (join_multicast_group(s, multicastAddr, interfaceAddr) == SOCKET_ERROR) goto cleanup;
/* Set the outgoing interface */
if (set_send_interface(s, interfaceAddr) == SOCKET_ERROR) goto cleanup;
/* For IPv6, ensure the scope ID is zero */
if (multicastAddr->ai_family == AF_INET6)
((SOCKADDR_IN6 *)multicastAddr->ai_addr)->sin6_scope_id = 0;
/* Set a 500ms receive timeout */
if (setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char *)&receiveTimeout, sizeof(receiveTimeout)) == SOCKET_ERROR) goto cleanup;
/* Allocate memory for thread parameters */
parameter = heap_alloc(sizeof(listenerThreadParams));
parameter->msgStorage = msgStorage;
parameter->listeningSocket = s;
hThread = CreateThread(NULL, 0, listening_thread, parameter, 0, NULL);
if (hThread == NULL) goto cleanup;
msgStorage->threadHandles[msgStorage->numThreadHandles] = hThread;
msgStorage->numThreadHandles++;
goto cleanup_addresses;
cleanup:
closesocket(s);
heap_free(parameter);
cleanup_addresses:
freeaddrinfo(multicastAddr);
freeaddrinfo(bindAddr);
freeaddrinfo(interfaceAddr);
}
int main(int argc, char *argv[])
{
int opt;
str destination_hostname = {.length = 0, .s = NULL};
uint16_t server_port = 8080, destination_port = COAP_DEFAULT_PORT;
char *endptr;
struct stat s;
while((opt = getopt(argc, argv, "D:P:p:f:h")) != EOF) {
switch(opt) {
case 'D':
destination_hostname.s = (unsigned char *)optarg;
destination_hostname.length = strlen(optarg);
resolve_address(&destination_hostname, (struct sockaddr *)&destination);
break;
case 'P':
destination_port = (uint16_t)strtoul(optarg, &endptr, 10);
if(*endptr != '\0') {
fprintf(stderr, "error: invalid port number: %s\n", optarg);
return EXIT_FAILURE;
}
break;
case 'p':
server_port = (uint16_t)strtoul(optarg, &endptr, 10);
if(*endptr != '\0') {
fprintf(stderr, "error: invalid port number: %s\n", optarg);
return EXIT_FAILURE;
}
break;
case 'f':
if(stat(optarg, &s) == -1) {
if(ENOENT == errno) {
/* does not exist */
fprintf(stderr, "error: %s: %s\n", optarg, strerror(errno));
return EXIT_FAILURE;
}
else {
perror("stat");
return EXIT_FAILURE;
}
} else {
if(S_ISDIR(s.st_mode)) {
/* it's a dir */
strncpy(static_files_path, optarg, 63);
static_files_path[63] = '\0';
fprintf(stderr, "Will serve static files of directory '%s'\n", static_files_path);
}
else {
/* exists but is no dir */
fprintf(stderr, "error: %s is not a directory\n", optarg);
return EXIT_FAILURE;
}
}
break;
case 'h':
fprintf(stderr, "usage: %s -D coap_host [-P coap_port] [-p HTTP_server_port] [-f static_files_dir]\n",
basename(argv[0]));
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
}
if(destination_hostname.s == NULL) {
fprintf(stderr, "error: please specify the target coap host of the proxy with the -D option\n");
return EXIT_FAILURE;
}
destination.sin_port = htons(destination_port);
// Register the clean function for when the program exists
if(atexit(cleanup) != 0) {
perror("atexit");
return EXIT_FAILURE;
}
// Also call it where a SIGINT is received
struct sigaction action;
memset(&action, 0, sizeof(action));
action.sa_handler = &signal_handler;
if(sigaction(SIGINT, &action, &old_action) != 0) {
perror("sigaction");
return EXIT_FAILURE;
}
start_http_server(server_port);
if(http_daemon == NULL) {
fprintf(stderr, "error: HTTP server failed to start: %s\n", strerror(errno));
return EXIT_FAILURE;
}
fprintf(stderr, "HTTP server is listening on port %u (using libmicrohttpd %s)\n", server_port, MHD_get_version());
// Create the CoAP context
coap_set_log_level(LOG_DEBUG);
coap_context = coap_create_context("0.0.0.0", NULL);
coap_register_response_handler(coap_context, coap_response_handler);
// Now let microhttpd accept HTTP requests and wait for a signal
pause();
return EXIT_SUCCESS;
}
//-- main() ///{{{1///////////////////////////////////////////
int main( int argc, char* argv[] )
{
size_t numClients = 1;
size_t numRepeats = 1;
const char* serverPort = 0;
const char* serverAddress = 0;
// get program arguments (server address and port)
if( argc < 4 || argc > 6 )
{
fprintf( stderr, "Error %s arguments\n",
argc < 4 ? "insufficient":"too many"
);
fprintf( stderr, " synopsis: %s <server> <port> <#num> [<#rep>] [<msg>]\n",
argv[0]
);
fprintf( stderr, " - <#num> -- number of clients to be emulated\n" );
fprintf( stderr, " - <#rep> -- number of times message is sent\n" );
fprintf( stderr, " - <msg> -- message sent by clients (see below)\n" );
fprintf( stderr, "\n" );
fprintf( stderr, "If the client message includes a `%%d' place holder, it\n" );
fprintf( stderr, "is replaced by an unique client id (0 < cid < #clients)\n" );
fprintf( stderr, "before the message is sent to the server.\n" );
fprintf( stderr, "The default message is `%s'\n", g_clientMessage );
return 1;
}
serverPort = argv[2];
serverAddress = argv[1];
numClients = atol(argv[3]);
if( argc >= 5 ) numRepeats = atol(argv[4]);
if( argc >= 6 ) g_clientMessage = argv[5];
// print short status
printf( "Simulating %zu clients.\n", numClients );
// initialize timer(s)
# if MEASURE_ROUND_TRIP_TIME
initialize_timer();
# endif
// resolve address of server once
sockaddr_in servAddr;
if( !resolve_address( servAddr, serverAddress, serverPort ) )
return 1;
// establish N connections (async)
printf( "Establishing %zu connections... \n", numClients );
size_t connErrors = 0;
ConnectionData* connections = new ConnectionData[numClients];
for( size_t i = 0; i < numClients; ++i )
{
# if MEASURE_CONNECT_TIME
connections[i].connectEnd = connections[i].connectStart = -1.0;
connections[i].connectStart = get_time_stamp();
# endif
connections[i].sock = connect_to_server_nonblock( servAddr );
connections[i].state = eConnStateConnecting;
// initialize client aux. data
connections[i].repeatsLeft = numRepeats-1;
# if MEASURE_ROUND_TRIP_TIME
connections[i].roundTripEnd = connections[i].roundTripStart = -1.0;
# endif
// on error: mark client as dead
if( -1 == connections[i].sock )
{
connections[i].state = eConnStateDead;
++connErrors;
}
}
if( connErrors > 0 )
{
printf( " %zu errors while establishing connections\n", connErrors );
if( connErrors == numClients )
{
printf( "All clients errored. Bye\n" );
return 1;
}
}
printf( " successfully initiated %zu connection attempts!\n",
numClients-connErrors );
// event handling loop
size_t clientsAlive = numClients - connErrors;
while( clientsAlive > 0 )
{
int maxfd = 0;
fd_set rset, wset;
FD_ZERO( &rset );
FD_ZERO( &wset );
// put active clients into their respective sets
for( size_t i = 0; i < numClients; ++i )
{
switch( connections[i].state )
{
case eConnStateSending:
case eConnStateConnecting:
FD_SET( connections[i].sock, &wset );
break;
case eConnStateReceiving:
FD_SET( connections[i].sock, &rset );
break;
case eConnStateDead: break;
}
maxfd = std::max( connections[i].sock, maxfd );
}
// wait for any event
int ret = select( maxfd+1, &rset, &wset, 0, 0 );
if( 0 == ret )
{
continue;
}
if( -1 == ret )
{
perror( "select()" );
return 1;
}
// handle events
size_t finishedClients = 0;
for( size_t i = 0; i < numClients; ++i )
{
if( connections[i].state == eConnStateDead ) continue;
bool keep = true;
if( FD_ISSET( connections[i].sock, &wset ) )
{
keep = client_process_send( i, connections[i] );
}
else if( FD_ISSET( connections[i].sock, &rset ) )
{
keep = client_process_recv( i, connections[i] );
}
if( !keep )
{
close( connections[i].sock );
connections[i].sock = -1;
connections[i].state = eConnStateDead;
++finishedClients;
}
}
clientsAlive -= finishedClients;
}
// gather and display some statistics
# if MEASURE_CONNECT_TIME
{
double avgTime = 0.0;
double maxTime = 0.0;
double minTime = std::numeric_limits<double>::infinity();
size_t timedItems = 0, erroredItems = 0;
for( size_t i = 0; i < numClients; ++i )
{
if( connections[i].connectEnd < 0.0 )
{
++erroredItems;
continue;
}
double delta = connections[i].connectEnd - connections[i].connectStart;
minTime = std::min( delta, minTime );
maxTime = std::max( delta, maxTime );
avgTime += delta;
++timedItems;
# if VERBOSE
printf( " - conn %zu : connect time = %f ms\n",
i, delta*1e3 );
# endif
}
avgTime /= timedItems;
printf( "Connect timing results for %zu successful connections\n",
timedItems );
printf( " - min time: %f ms\n", minTime*1e3 );
printf( " - max time: %f ms\n", maxTime*1e3 );
printf( " - average time: %f ms\n", avgTime*1e3 );
printf( " (%zu connections failed!)\n", erroredItems );
}
# endif
# if MEASURE_ROUND_TRIP_TIME
{
double avgTime = 0.0;
double maxTime = 0.0;
double minTime = std::numeric_limits<double>::infinity();
size_t timedItems = 0;
for( size_t i = 0; i < numClients; ++i )
{
if( connections[i].roundTripEnd < 0.0 ) continue;
double delta = connections[i].roundTripEnd - connections[i].roundTripStart;
minTime = std::min( delta, minTime );
maxTime = std::max( delta, maxTime );
avgTime += delta;
++timedItems;
# if VERBOSE
printf( " - conn %zu : round trip time = %f ms for %zu round trips\n",
i, delta*1e3, numRepeats );
# endif
}
avgTime /= timedItems;
printf( "Roundtrip timing results for %zu connections for %zu round trips\n",
timedItems, numRepeats );
printf( " - min time: %f ms\n", minTime*1e3 );
printf( " - max time: %f ms\n", maxTime*1e3 );
printf( " - average time: %f ms\n", avgTime*1e3 );
}
# endif
// clean up
for( size_t i = 0; i < numClients; ++i )
close( connections[i].sock );
delete [] connections;
return 0;
}
char *resolve_address(char *hostname, nameserver **nameservers, int ns_count) {
// The hostname we'll be looking up in any recursive call
char *newhostname = hostname;
// Stuff we'll use after getting ahold of a nameserver
uint8_t answerbuf[1500];
// Build a socket with a timeout
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if(sock < 0) {
perror("Creating socket failed: ");
exit(1);
}
struct timeval timeout;
timeout.tv_sec = 1;
timeout.tv_usec = 0;
setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
// Loop to contact a nameserver
int chosen_server = rand()%ns_count;
// The nameserver we'll be using to do the query
nameserver *active_ns;
// Number of times left to try contacting a nameserver
int attempts_left = MAX_ATTEMPTS * ns_count;
while ( attempts_left-- > 0 ) {
// Try a nameserver
active_ns = nameservers[chosen_server];
in_addr_t nameserver_addr=inet_addr(active_ns->server_addr);
// construct the query message
uint8_t query[1500];
int query_len=construct_query(query,1500,hostname);
struct sockaddr_in addr; // internet socket address data structure
addr.sin_family = AF_INET;
addr.sin_port = htons(53); // port 53 for DNS
addr.sin_addr.s_addr = nameserver_addr; // destination address (any local for now)
if (debug) {
printf("How about nameserver %s?\n", active_ns->server_addr);
}
int send_count = sendto(sock, query, query_len, 0,
(struct sockaddr*)&addr,sizeof(addr));
if(send_count<0) {
perror("Send failed");
exit(1);
}
// Await the response
int rec_count = recv(sock,answerbuf,1500,0);
// Check for errors while receiving
if ((rec_count < 1) && ((errno == EAGAIN) || (errno == EWOULDBLOCK))) {
if (debug) {
printf("Timed out while waiting for nameserver %s.\n", active_ns->server_addr);
}
// Try choosing another nameserver randomly
chosen_server = rand()%ns_count;
} else {
break;
}
}
if ( attempts_left <= 0 ) {
fprintf(stderr, "Could not contact any nameservers.\n");
exit(1);
}
if (debug) {
printf("Resolving %s using server %s out of %d\n",
hostname, active_ns->server_addr, ns_count);
}
// parse the response to get our answer
struct dns_hdr *ans_hdr=(struct dns_hdr*)answerbuf;
uint8_t *answer_ptr = answerbuf + sizeof(struct dns_hdr);
// now answer_ptr points at the first question.
int question_count = ntohs(ans_hdr->q_count);
int answer_count = ntohs(ans_hdr->a_count);
int auth_count = ntohs(ans_hdr->auth_count);
int other_count = ntohs(ans_hdr->other_count);
if (debug) {
int resource_count = question_count + answer_count + auth_count + other_count;
printf("%d questions, %d answers, %d authoritative records, and %d others = %d resource records total\n",
question_count, answer_count, auth_count, other_count, resource_count);
}
// skip past all questions
int q;
for(q=0;q<question_count;q++) {
char string_name[255];
memset(string_name,0,255);
int size=from_dns_style(answerbuf,answer_ptr,string_name);
answer_ptr+=size;
answer_ptr+=4; //2 for type, 2 for class
}
int a;
int got_answer=0;
// now answer_ptr points at the first answer. loop through
// all answers in all sections
nameserver *new_nameservers[100];
int ns_index = 0;
for(a=0;a<answer_count+auth_count+other_count;a++) {
// first the name this answer is referring to
char string_name[255];
int dnsnamelen=from_dns_style(answerbuf,answer_ptr,string_name);
answer_ptr += dnsnamelen;
// then fixed part of the RR record
struct dns_rr* rr = (struct dns_rr*)answer_ptr;
answer_ptr+=sizeof(struct dns_rr);
const uint8_t RECTYPE_A=1;
const uint8_t RECTYPE_NS=2;
const uint8_t RECTYPE_CNAME=5;
const uint8_t RECTYPE_SOA=6;
const uint8_t RECTYPE_PTR=12;
const uint8_t RECTYPE_AAAA=28;
if(htons(rr->type)==RECTYPE_A) {
char *ip_addr = inet_ntoa(*((struct in_addr *)answer_ptr));
if (debug)
printf("The name %s resolves to IP addr: %s\n",
string_name,
ip_addr);
got_answer=1;
// Are we done?
if ( !strcasecmp(string_name, newhostname) ) {
delete_nameservers(new_nameservers, ns_index);
if (newhostname != hostname)
free(newhostname);
return strdup(ip_addr);
}
// Try to match some IPs up with symbolic hostnames for nameservers
int i;
for ( i=0; i<ns_index; i++ ) {
nameserver *new_ns = new_nameservers[i];
if ( !strcasecmp(string_name,new_ns->server) ) {
new_ns->server_addr = strdup(ip_addr);
break;
}
}
}
// NS record
else if(htons(rr->type)==RECTYPE_NS) {
char ns_string[255];
int ns_len=from_dns_style(answerbuf,answer_ptr,ns_string);
if(debug)
printf("The name %s can be resolved by NS: %s\n",
string_name, ns_string);
// Keep maximum number of nameservers
if ( ns_index < MAX_NAMESERVERS ) {
nameserver *new_ns = nameserver_create(ns_string, NULL);
new_nameservers[ns_index++] = new_ns;
}
got_answer=1;
}
// CNAME record
else if(htons(rr->type)==RECTYPE_CNAME) {
char ns_string[255];
int ns_len=from_dns_style(answerbuf,answer_ptr,ns_string);
if(debug) {
printf("The name %s is also known as %s.\n",
string_name, ns_string);
}
if ( !strcasecmp(string_name,newhostname) ) {
if ( newhostname != hostname )
free(newhostname);
newhostname = strdup(ns_string);
}
got_answer=1;
}
// PTR record
else if(htons(rr->type)==RECTYPE_PTR) {
char ns_string[255];
int ns_len=from_dns_style(answerbuf,answer_ptr,ns_string);
if (debug) {
printf("The host at %s is also known as %s.\n",
string_name, ns_string);
}
got_answer=1;
delete_nameservers(new_nameservers, ns_index);
if (newhostname != hostname)
free(newhostname);
return strdup(ns_string);
}
// SOA record
else if(htons(rr->type)==RECTYPE_SOA) {
if(debug) {
printf("Ignoring SOA record\n");
}
}
// AAAA record
else if(htons(rr->type)==RECTYPE_AAAA) {
if(debug) {
printf("Ignoring IPv6 record\n");
}
}
else {
if(debug) {
printf("got unknown record type %hu\n",htons(rr->type));
}
}
answer_ptr+=htons(rr->datalen);
}
shutdown(sock,SHUT_RDWR);
close(sock);
if ( ns_index > 0 ) {
int i;
for ( i=0; i<ns_index; i++ ) {
nameserver *ns = new_nameservers[i];
// Make sure we have the IP address of this nameserver
if ( !ns->server_addr ) {
if (debug) {
printf("Need to resolve IP address of nameserver %s\n", ns->server);
}
ns->server_addr = resolve_address(ns->server, root_servers, num_root_servers);
if ( !ns->server_addr && debug ) {
printf("Failed to retrieve IP address for %s.\n", ns->server);
}
}
}
if (debug) {
printf("now resolving the hostname %s...\n", newhostname);
}
// Free old nameservers array
char *result = resolve_address(newhostname, new_nameservers, ns_index);
if (newhostname != hostname)
free(newhostname);
delete_nameservers(new_nameservers, ns_index);
return result;
}
if (newhostname != hostname)
free(newhostname);
delete_nameservers(new_nameservers, ns_index);
return NULL;
}
int
scan_metadata_icy(char *url, struct media_file_info *mfi)
{
struct evhttp_connection *evcon;
struct evhttp_request *req;
struct icy_ctx *ctx;
int ret;
int i;
status = ICY_INIT;
/* We can set this straight away */
mfi->url = strdup(url);
ctx = (struct icy_ctx *)malloc(sizeof(struct icy_ctx));
if (!ctx)
{
DPRINTF(E_LOG, L_SCAN, "Out of memory for ICY metadata context\n");
goto no_icy;
}
memset(ctx, 0, sizeof(struct icy_ctx));
ctx->url = evhttp_encode_uri(url);
/* TODO https */
av_url_split(NULL, 0, NULL, 0, ctx->hostname, sizeof(ctx->hostname), &ctx->port, ctx->path, sizeof(ctx->path), ctx->url);
if (ctx->port < 0)
ctx->port = 80;
/* Resolve IP address */
ret = resolve_address(ctx->hostname, ctx->address, sizeof(ctx->address));
if (ret < 0)
{
DPRINTF(E_LOG, L_SCAN, "Could not find IP address of %s\n", ctx->hostname);
return -1;
}
DPRINTF(E_DBG, L_SCAN, "URL %s converted to hostname %s, port %d, path %s, IP %s\n", ctx->url, ctx->hostname, ctx->port, ctx->path, ctx->address);
/* Set up connection */
evcon = evhttp_connection_new(ctx->address, (unsigned short)ctx->port);
if (!evcon)
{
DPRINTF(E_LOG, L_SCAN, "Could not create connection to %s\n", ctx->hostname);
goto no_icy;
}
evhttp_connection_set_base(evcon, evbase_main);
evhttp_connection_set_timeout(evcon, ICY_TIMEOUT);
/* Set up request */
req = evhttp_request_new(scan_icy_request_cb, mfi);
if (!req)
{
DPRINTF(E_LOG, L_SCAN, "Could not create request to %s\n", ctx->hostname);
evhttp_connection_free(evcon);
goto no_icy;
}
req->header_cb = scan_icy_header_cb;
evhttp_add_header(req->output_headers, "Host", ctx->hostname);
evhttp_add_header(req->output_headers, "Icy-MetaData", "1");
/* Make request */
status = ICY_WAITING;
ret = evhttp_make_request(evcon, req, EVHTTP_REQ_GET, ctx->path);
if (ret < 0)
{
DPRINTF(E_LOG, L_SCAN, "Could not make request to %s\n", ctx->hostname);
status = ICY_DONE;
evhttp_connection_free(evcon);
goto no_icy;
}
DPRINTF(E_INFO, L_SCAN, "Making request to %s asking for ICY (Shoutcast) metadata\n", url);
/* Can't count on server support for ICY metadata, so
* while waiting for a reply make a parallel call to scan_metadata_ffmpeg.
* This call will also determine final return value.
*/
no_icy:
ret = scan_metadata_ffmpeg(url, mfi);
/* Wait till ICY request completes or we reach timeout */
for (i = 0; (status == ICY_WAITING) && (i <= ICY_TIMEOUT); i++)
sleep(1);
free_icy(ctx);
DPRINTF(E_DBG, L_SCAN, "scan_metadata_icy exiting with status %d after waiting %d sec\n", status, i);
return ret;
}
int send_data(lo_address a, lo_server from, char *data, const size_t data_len)
{
int ret=0;
int sock=-1;
#ifdef WIN32
if(!initWSock()) return -1;
#endif
if (data_len > LO_MAX_MSG_SIZE) {
a->errnum = 99;
a->errstr = "Attempted to send message in excess of maximum "
"message size";
return -1;
}
// Resolve the destination address, if not done already
if (!a->ai) {
ret = resolve_address( a );
if (ret) return ret;
}
// Re-use existing socket?
if (from) {
sock = from->sockets[0].fd;
} else if (a->protocol == LO_UDP && lo_client_sockets.udp!=-1) {
sock = lo_client_sockets.udp;
} else {
if (a->socket==-1) {
ret = create_socket( a );
if (ret) return ret;
}
sock = a->socket;
}
// Send Length of the following data
if (a->protocol == LO_TCP) {
int32_t size = htonl(data_len);
ret = send(sock, &size, sizeof(size), MSG_NOSIGNAL);
}
// Send the data
if (a->protocol == LO_UDP) {
if (a->ttl >= 0) {
unsigned char ttl = (unsigned char)a->ttl;
setsockopt(sock,IPPROTO_IP,IP_MULTICAST_TTL,&ttl,sizeof(ttl));
}
ret = sendto(sock, data, data_len, MSG_NOSIGNAL,
a->ai->ai_addr, a->ai->ai_addrlen);
} else {
ret = send(sock, data, data_len, MSG_NOSIGNAL);
}
if (a->protocol == LO_TCP && ret == -1) {
close(a->socket);
a->socket=-1;
}
if (ret == -1) {
a->errnum = geterror();
a->errstr = NULL;
} else {
a->errnum = 0;
a->errstr = NULL;
}
return ret;
}
int main(int argc, char** argv)
{
if(argc<2) usage();
char *hostname=0;
char *given_ns=0;
char *optString = "-d-n:-i:";
int opt = getopt( argc, argv, optString );
while( opt != -1 ) {
switch( opt ) {
case 'd':
debug = 1;
break;
case 'n':
given_ns = optarg;
break;
case 'i':
hostname = optarg;
break;
case '?':
usage();
exit(1);
default:
usage();
exit(1);
}
opt = getopt( argc, argv, optString );
}
/* initialize root servers list */
if (!given_ns) {
// Use root-servers.txt
num_root_servers = 0;
FILE *servers_in = fopen("root-servers.txt","r");
if (!servers_in) {
perror("fopen");
exit(1);
}
char root_addr[256];
for ( num_root_servers=0; num_root_servers<MAX_NAMESERVERS; num_root_servers++ ) {
if (EOF != fscanf(servers_in, "%s\n", &root_addr[0])) {
nameserver *ns = nameserver_create(NULL, root_addr);
root_servers[num_root_servers] = ns;
} else {
fclose(servers_in);
break;
}
}
} else {
nameserver *ns = nameserver_create(NULL, given_ns);
root_servers[0] = ns;
num_root_servers = 1;
}
if (!hostname) {
usage();
exit(1);
}
// Setup random number generation
srand(time(NULL));
// Try to resolve the given servername or ip address
char *result = resolve_address(hostname, root_servers, num_root_servers);
if ( result ) {
printf("%s resolves to %s\n", hostname, result);
} else {
printf("Could not resolve the name %s\n", hostname);
}
// Cleanup
free(result);
delete_nameservers(root_servers, num_root_servers);
return 0;
}
int main(int argc, char **argv) {
void *tabpoll;
dia_context_t *dia;
int result;
char addr_str[200] = "::1";
char port_str[10] = "5683";
int opt;
int log_level = 0;
int count = 1, i;
int group = 1;
char loss = 0;
while ((opt = getopt(argc, argv, "A:p:v:m:f:n:g:R:l")) != -1) {
switch (opt) {
case 'A' :
strncpy(addr_str, optarg, 200-1);
addr_str[200 - 1] = '\0';
break;
case 'p' :
strncpy(port_str, optarg, 10-1);
port_str[10 - 1] = '\0';
break;
case 'm' :
strcpy (method, optarg);
break;
case 'R' :
strcpy (reqEntity, optarg);
break;
case 'l' :
loss = 1;
break;
case 'f' :
strcpy (file, optarg);
break;
case 'n' :
count = atoi(optarg);
break;
case 'g' :
group = atoi(optarg);
break;
case 'v' :
log_level = strtol(optarg, NULL, 10);
break;
default:
usage();
exit( 1 );
}
}
if (optind == argc) {
fprintf (stderr, "You must specify a targetID\n");
usage();
exit (1);
}
char *targetID = argv[optind];
dia = dia_createContext(&callbacks);
if (!dia) {
fprintf (stderr, "dia_createContext failed\n");
usage();
exit (1);
}
dia_withLoss (dia, loss);
tabpoll = rtl_pollInit ();
sock = resolve_address(addr_str, &addr);
addr.addr.sin.sin_port = htons(atoi(port_str));
rtl_pollAdd (tabpoll, sock, network_input, network_request, dia, NULL);
signal(SIGINT, handle_sigint);
for (i=0; i<count; i++) {
if (!strcmp(method, "create"))
do_create (dia, targetID, group);
else if (!strcmp(method, "retrieve"))
do_retrieve (dia, targetID, group);
else if (!strcmp(method, "update"))
do_update (dia, targetID, group);
else if (!strcmp(method, "delete"))
do_delete (dia, targetID, group);
else {
usage ();
exit (1);
}
dIa_status (dia);
while ( more ) {
struct dia_timeval tv;
dIa_nextTimer (dia, &tv);
result = rtl_poll(tabpoll, (tv.tv_sec*1000) + (tv.tv_usec/1000));
}
dIa_status (dia);
if (quit)
break;
}
return 0;
}
int main(int argc, char **argv)
{
struct sockaddr_in pulladdr;
struct sockaddr_in pushaddr;
int pullsock;
int pushsock;
int err;
int recovering = 0;
struct arguments args;
struct log *log = NULL;
#ifdef TCPR
int tcprsock;
struct tcpr_ip4 state;
#endif
//OpenSSL
SSL_load_error_strings();
ERR_load_BIO_strings();
ERR_load_SSL_strings();
SSL_library_init();
OpenSSL_add_all_algorithms();
/////////
memset(&args, 0, sizeof(args));
parse_arguments(&args, argc, argv);
err = resolve_address(&pulladdr, args.pullhost, args.pullport);
if (err) {
fprintf(stderr, "%s:%s: %s\n", args.pullhost, args.pullport,
gai_strerror(err));
exit(EXIT_FAILURE);
}
err = resolve_address(&pushaddr, args.pushhost, args.pushport);
if (err) {
fprintf(stderr, "%s:%s: %s\n", args.pushhost, args.pushport,
gai_strerror(err));
exit(EXIT_FAILURE);
}
if (!args.port)
args.port = 10000;
#ifdef TCPR
printf("Connecting to TCPR.\n");
tcprsock = connect_to_tcpr(&pulladdr);
if (tcprsock < 0) {
perror("Connecting to TCPR");
exit(EXIT_FAILURE);
}
pulladdr1 = pulladdr;
port1 = args.port;
tcpr_sock = tcprsock;
printf("Waiting for existing master, if any.\n");
if (get_tcpr_state(&state, tcprsock, &pulladdr, args.port) < 0) {
perror("Getting TCPR state");
exit(EXIT_FAILURE);
}
recovering = wait_for_master(&state);
if (recovering) {
printf("Recovering from failed master.\n");
if (claim_tcpr_state(&state, tcprsock, &pulladdr, args.port) < 0) {
perror("Claiming TCPR state");
exit(EXIT_FAILURE);
}
} else {
printf("Creating fresh connection.\n");
}
handle_slaves();
#endif /* TCPR */
printf("Connecting to data source.\n");
pullsock = connect_to_peer(&pulladdr, args.port);
if (pullsock < 0) {
perror("Connecting to data source");
exit(EXIT_FAILURE);
}
printf("Connecting to data sink.\n");
pushsock = connect_to_peer(&pushaddr, 0);
if (pushsock < 0) {
perror("Connecting to data sink");
exit(EXIT_FAILURE);
}
if (args.logprefix) {
printf("Opening log.\n");
log = log_start(args.logprefix, args.logbytes, args.logcount);
}
#ifdef TCPR
if (get_tcpr_state(&state, tcprsock, &pulladdr, args.port) < 0) {
perror("Getting TCPR state");
exit(EXIT_FAILURE);
}
#endif
if (!recovering) {
printf("Sending ID to data source.\n");
if (send(pullsock, args.id, strlen(args.id), 0) < 0) {
perror("Sending session ID");
exit(EXIT_FAILURE);
}
}
get_tcpr_state(&state1, tcpr_sock, &pulladdr1, port1);
get_tcpr_state(&state, tcpr_sock, &pulladdr, args.port);
//BIO_set_callback(sbio,test_write);
//BIO_set_callback(sbio1,test_write);
printf("Copying data from source to sink.\n");
#ifdef TCPR
if (copy_data(&state, log, pullsock, pushsock, tcprsock) < 0) {
#else
if (copy_data(log, pullsock, pushsock) < 0) {
#endif
perror("Copying data");
exit(EXIT_FAILURE);
}
printf("Done.\n");
#ifdef TCPR
close(tcprsock);
#endif
close(pullsock);
close(pushsock);
return EXIT_SUCCESS;
}
int
main(int argc, char **argv) {
dtls_context_t *the_context = NULL;
log_t log_level = DTLS_LOG_WARN;
fd_set rfds, wfds;
struct timeval timeout;
int fd, opt, result;
int on = 1;
int ecdh_anon_enalbe = DTLS_CIPHER_DISABLE;
struct sockaddr_in6 listen_addr;
memset(&listen_addr, 0, sizeof(struct sockaddr_in6));
/* fill extra field for 4.4BSD-based systems (see RFC 3493, section 3.4) */
#if defined(SIN6_LEN) || defined(HAVE_SOCKADDR_IN6_SIN6_LEN)
listen_addr.sin6_len = sizeof(struct sockaddr_in6);
#endif
listen_addr.sin6_family = AF_INET6;
listen_addr.sin6_port = htons(DEFAULT_PORT);
listen_addr.sin6_addr = in6addr_any;
while ((opt = getopt(argc, argv, "A:p:v:a:")) != -1) {
switch (opt) {
case 'A' :
if (resolve_address(optarg, (struct sockaddr *)&listen_addr) < 0) {
fprintf(stderr, "cannot resolve address\n");
exit(-1);
}
break;
case 'p' :
listen_addr.sin6_port = htons(atoi(optarg));
break;
case 'v' :
log_level = strtol(optarg, NULL, 10);
break;
case 'a':
if( strcmp(optarg, "enable") == 0)
ecdh_anon_enalbe = DTLS_CIPHER_ENABLE;
break;
default:
usage(argv[0], dtls_package_version());
exit(1);
}
}
dtls_set_log_level(log_level);
/* init socket and set it to non-blocking */
fd = socket(listen_addr.sin6_family, SOCK_DGRAM, 0);
if (fd < 0) {
dtls_alert("socket: %s\n", strerror(errno));
return 0;
}
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) ) < 0) {
dtls_alert("setsockopt SO_REUSEADDR: %s\n", strerror(errno));
}
#if 0
flags = fcntl(fd, F_GETFL, 0);
if (flags < 0 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
dtls_alert("fcntl: %s\n", strerror(errno));
goto error;
}
#endif
on = 1;
#ifdef IPV6_RECVPKTINFO
if (setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on, sizeof(on) ) < 0) {
#else /* IPV6_RECVPKTINFO */
if (setsockopt(fd, IPPROTO_IPV6, IPV6_PKTINFO, &on, sizeof(on) ) < 0) {
#endif /* IPV6_RECVPKTINFO */
dtls_alert("setsockopt IPV6_PKTINFO: %s\n", strerror(errno));
}
if (bind(fd, (struct sockaddr *)&listen_addr, sizeof(listen_addr)) < 0) {
dtls_alert("bind: %s\n", strerror(errno));
goto error;
}
dtls_init();
the_context = dtls_new_context(&fd);
/* enable/disable tls_ecdh_anon_with_aes_128_cbc_sha */
dtls_enables_anon_ecdh(the_context, ecdh_anon_enalbe);
dtls_set_handler(the_context, &cb);
while (1) {
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_SET(fd, &rfds);
/* FD_SET(fd, &wfds); */
timeout.tv_sec = 5;
timeout.tv_usec = 0;
result = select( fd+1, &rfds, &wfds, 0, &timeout);
if (result < 0) { /* error */
if (errno != EINTR)
perror("select");
} else if (result == 0) { /* timeout */
} else { /* ok */
if (FD_ISSET(fd, &wfds))
;
else if (FD_ISSET(fd, &rfds)) {
dtls_handle_read(the_context);
}
}
}
error:
dtls_free_context(the_context);
exit(0);
}
