static void on_connected(void *arg, grpc_endpoint *tcp) {
internal_request *req = arg;
gpr_log(GPR_DEBUG, "%s", __FUNCTION__);
if (!tcp) {
next_address(req);
return;
}
req->ep = tcp;
if (req->use_ssl) {
grpc_channel_security_context *ctx = NULL;
const unsigned char *pem_root_certs = NULL;
size_t pem_root_certs_size = grpc_get_default_ssl_roots(&pem_root_certs);
if (pem_root_certs == NULL || pem_root_certs_size == 0) {
gpr_log(GPR_ERROR, "Could not get default pem root certs.");
finish(req, 0);
return;
}
GPR_ASSERT(grpc_httpcli_ssl_channel_security_context_create(
pem_root_certs, pem_root_certs_size, req->host, &ctx) ==
GRPC_SECURITY_OK);
grpc_setup_secure_transport(&ctx->base, tcp, on_secure_transport_setup_done,
req);
grpc_security_context_unref(&ctx->base);
} else {
start_write(req);
}
}
static void on_read(void *user_data, gpr_slice *slices, size_t nslices,
grpc_endpoint_cb_status status) {
internal_request *req = user_data;
size_t i;
for (i = 0; i < nslices; i++) {
if (GPR_SLICE_LENGTH(slices[i])) {
req->have_read_byte = 1;
if (!grpc_httpcli_parser_parse(&req->parser, slices[i])) {
finish(req, 0);
goto done;
}
}
}
switch (status) {
case GRPC_ENDPOINT_CB_OK:
grpc_endpoint_notify_on_read(req->ep, on_read, req);
break;
case GRPC_ENDPOINT_CB_EOF:
case GRPC_ENDPOINT_CB_ERROR:
case GRPC_ENDPOINT_CB_SHUTDOWN:
if (!req->have_read_byte) {
next_address(req);
} else {
finish(req, grpc_httpcli_parser_eof(&req->parser));
}
break;
}
done:
for (i = 0; i < nslices; i++) {
gpr_slice_unref(slices[i]);
}
}
static inline void
bench_iteration()
{
const long line_size = bench_settings.line_size;
for (long i = 0; i < bench_size; i += line_size)
ACCESS(next_address());
}
static void done_write(grpc_exec_ctx *exec_ctx, void *arg, bool success) {
internal_request *req = arg;
if (success) {
on_written(exec_ctx, req);
} else {
next_address(exec_ctx, req);
}
}
static void on_connected(void *arg, grpc_endpoint *tcp) {
internal_request *req = arg;
if (!tcp) {
next_address(req);
return;
}
req->handshaker->handshake(req, tcp, req->host, on_handshake_done);
}
static void on_resolved(void *arg, grpc_resolved_addresses *addresses) {
internal_request *req = arg;
if (!addresses) {
finish(req, 0);
return;
}
req->addresses = addresses;
req->next_address = 0;
next_address(req);
}
static void on_resolved(void *arg, grpc_resolved_addresses *addresses) {
internal_request *req = arg;
gpr_log(GPR_DEBUG, "%s", __FUNCTION__);
if (!addresses) {
finish(req, 0);
return;
}
req->addresses = addresses;
req->next_address = 0;
next_address(req);
}
static void on_handshake_done(void *arg, grpc_endpoint *ep) {
internal_request *req = arg;
if (!ep) {
next_address(req);
return;
}
req->ep = ep;
start_write(req);
}
static void on_connected(grpc_exec_ctx *exec_ctx, void *arg, bool success) {
internal_request *req = arg;
if (!req->ep) {
next_address(exec_ctx, req);
return;
}
req->handshaker->handshake(
exec_ctx, req, req->ep,
req->ssl_host_override ? req->ssl_host_override : req->host,
on_handshake_done);
}
static void done_write(void *arg, grpc_endpoint_cb_status status) {
internal_request *req = arg;
switch (status) {
case GRPC_ENDPOINT_CB_OK:
on_written(req);
break;
case GRPC_ENDPOINT_CB_EOF:
case GRPC_ENDPOINT_CB_SHUTDOWN:
case GRPC_ENDPOINT_CB_ERROR:
next_address(req);
break;
}
}
static GSocketAddress *
soup_address_address_enumerator_next_finish (GSocketAddressEnumerator *enumerator,
GAsyncResult *result,
GError **error)
{
SoupAddressAddressEnumerator *addr_enum =
SOUP_ADDRESS_ADDRESS_ENUMERATOR (enumerator);
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
else
return next_address (addr_enum);
}
static GSocketAddress *
soup_address_address_enumerator_next (GSocketAddressEnumerator *enumerator,
GCancellable *cancellable,
GError **error)
{
SoupAddressAddressEnumerator *addr_enum =
SOUP_ADDRESS_ADDRESS_ENUMERATOR (enumerator);
SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr_enum->addr);
if (!priv->sockaddr) {
if (resolve_sync_internal (addr_enum->addr, cancellable, error) != SOUP_STATUS_OK)
return NULL;
}
return next_address (addr_enum);
}
static void
got_addresses (SoupAddress *addr, guint status, gpointer user_data)
{
GTask *task = user_data;
GError *error;
error = g_object_get_data (G_OBJECT (addr), "async-resolved-error");
if (error)
g_task_return_error (task, g_error_copy (error));
else {
GSocketAddress *addr;
addr = next_address (g_task_get_source_object (task));
g_task_return_pointer (task, addr, g_object_unref);
}
g_object_unref (task);
}
void Evaluator::set_address()
{
Cell addr(0, 0);
Nodes & instructions = root->children;
for (auto i : instructions)
{
Instruction * pi = get<Instruction>(LNFUN, i);
bool curl = false;
Cell save_addr;
if (pi->typ == Instruction::eCurl)
try
{
curl = true;
save_addr = addr;
addr = root->comp->proc.x2ts(root->comp->random());
}
catch (const char * e) { throw Err(e, pi->tok()); }
Nodes & lis = i->children;
for (auto l : lis )
{
Litem * pl = get<Litem>(LNFUN, l);
try
{
assign_address(pl, addr);
next_address(addr);
}
catch (string e) { throw Err(e, pl->tok()); }
// finished with Litem - safe to remove labels
pl->children.pop_back();
} // next litem
// finished instruction, resore addr if curl
if (curl)
addr = save_addr;
} // next instruction
}
static void
soup_address_address_enumerator_next_async (GSocketAddressEnumerator *enumerator,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
SoupAddressAddressEnumerator *addr_enum =
SOUP_ADDRESS_ADDRESS_ENUMERATOR (enumerator);
SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr_enum->addr);
GTask *task;
task = g_task_new (enumerator, cancellable, callback, user_data);
if (!priv->sockaddr) {
soup_address_resolve_async (addr_enum->addr,
g_main_context_get_thread_default (),
cancellable, got_addresses, task);
} else {
g_task_return_pointer (task, next_address (addr_enum), g_object_unref);
g_object_unref (task);
}
}
static void on_read(grpc_exec_ctx *exec_ctx, void *user_data, bool success) {
internal_request *req = user_data;
size_t i;
for (i = 0; i < req->incoming.count; i++) {
if (GPR_SLICE_LENGTH(req->incoming.slices[i])) {
req->have_read_byte = 1;
if (!grpc_httpcli_parser_parse(&req->parser, req->incoming.slices[i])) {
finish(exec_ctx, req, 0);
return;
}
}
}
if (success) {
do_read(exec_ctx, req);
} else if (!req->have_read_byte) {
next_address(exec_ctx, req);
} else {
finish(exec_ctx, req, grpc_httpcli_parser_eof(&req->parser));
}
}
int netzInfo(char *pythonIp, netinfo *nInfo) {
int timeout=10000, use137=0, bandwidth=0, send_ok=0;
extern char *optarg;
extern int optind;
char* target_string;
char* filename =NULL;
struct ip_range range;
void *buff;
int sock;
unsigned int addr_size;
struct sockaddr_in src_sockaddr, dest_sockaddr;
struct in_addr *prev_in_addr=NULL;
struct in_addr *next_in_addr;
struct timeval select_timeout, last_send_time, current_time, diff_time, send_interval;
struct timeval transmit_started, now, recv_time;
struct nb_host_info* hostinfo;
fd_set* fdsr;
fd_set* fdsw;
int size;
int pos =0;
struct list* scanned;
my_uint32_t rtt_base; /* Base time (seconds) for round trip time calculations */
float rtt; /* most recent measured RTT, seconds */
float srtt=0; /* smoothed rtt estimator, seconds */
float rttvar=0.75; /* smoothed mean deviation, seconds */
double delta; /* used in retransmit timeout calculations */
int rto, retransmits=0, more_to_send=1, i;
char errmsg[80];
char str[80];
FILE* targetlist=NULL;
if((target_string=strdup(pythonIp))==NULL)
{
err_die("Malloc failed.\n", quiet);
}
if(!set_range(target_string, &range)) {
printf("Error: %s is not an IP address or address range.\n", target_string);
free(target_string);
};
/* Finished with options */
/*************************/
/* Prepare socket and address structures */
/*****************************************/
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sock < 0)
err_die("Failed to create socket", quiet);
bzero((void*)&src_sockaddr, sizeof(src_sockaddr));
src_sockaddr.sin_family = AF_INET;
if(use137) src_sockaddr.sin_port = htons(NB_DGRAM);
if (bind(sock, (struct sockaddr *)&src_sockaddr, sizeof(src_sockaddr)) == -1)
err_die("Failed to bind", quiet);
fdsr=malloc(sizeof(fd_set));
if(!fdsr) err_die("Malloc failed", quiet);
FD_ZERO(fdsr);
FD_SET(sock, fdsr);
fdsw=malloc(sizeof(fd_set));
if(!fdsw) err_die("Malloc failed", quiet);
FD_ZERO(fdsw);
FD_SET(sock, fdsw);
/* timeout is in milliseconds */
//select_timeout.tv_sec = timeout / 1000;
//select_timeout.tv_usec = (timeout % 1000) * 1000; /* Microseconds */
select_timeout.tv_sec = 60; /* Default 1 min to survive ARP timeouts */
select_timeout.tv_usec = 0;
addr_size = sizeof(struct sockaddr_in);
next_in_addr = malloc(sizeof(struct in_addr));
if(!next_in_addr) err_die("Malloc failed", quiet);
buff=malloc(BUFFSIZE);
if(!buff) err_die("Malloc failed", quiet);
/* Calculate interval between subsequent sends */
timerclear(&send_interval);
if(bandwidth) send_interval.tv_usec =
(NBNAME_REQUEST_SIZE + UDP_HEADER_SIZE + IP_HEADER_SIZE)*8*1000000 /
bandwidth; /* Send interval in microseconds */
else /* Assuming 10baseT bandwidth */
send_interval.tv_usec = 1; /* for 10baseT interval should be about 1 ms */
if (send_interval.tv_usec >= 1000000) {
send_interval.tv_sec = send_interval.tv_usec / 1000000;
send_interval.tv_usec = send_interval.tv_usec % 1000000;
}
gettimeofday(&last_send_time, NULL); /* Get current time */
rtt_base = last_send_time.tv_sec;
/* Send queries, receive answers and print results */
/***************************************************/
scanned = new_list();
for(i=0; i <= retransmits; i++) {
gettimeofday(&transmit_started, NULL);
while ( (select(sock+1, fdsr, fdsw, NULL, &select_timeout)) > 0) {
if(FD_ISSET(sock, fdsr)) {
if ( (size = recvfrom(sock, buff, BUFFSIZE, 0,
(struct sockaddr*)&dest_sockaddr, &addr_size)) <= 0 ) {
snprintf(errmsg, 80, "%s\tRecvfrom failed", inet_ntoa(dest_sockaddr.sin_addr));
err_print(errmsg, quiet);
continue;
};
gettimeofday(&recv_time, NULL);
memset(&hostinfo, 0, sizeof(hostinfo));
hostinfo = (struct nb_host_info*)parse_response(buff, size);
if(!hostinfo) {
err_print("parse_response returned NULL", quiet);
continue;
};
/* If this packet isn't a duplicate */
if(insert(scanned, ntohl(dest_sockaddr.sin_addr.s_addr))) {
rtt = recv_time.tv_sec +
recv_time.tv_usec/1000000 - rtt_base -
hostinfo->header->transaction_id/1000;
/* Using algorithm described in Stevens'
Unix Network Programming */
delta = rtt - srtt;
srtt += delta / 8;
if(delta < 0.0) delta = - delta;
rttvar += (delta - rttvar) / 4 ;
if (hostinfo->names == 0x0) {
printf("hostinfo->names == NULL\n");
} else {
python_hostinfo(dest_sockaddr.sin_addr, hostinfo, nInfo, pos);
pos ++;
}
};
free(hostinfo);
};
FD_ZERO(fdsr);
FD_SET(sock, fdsr);
/* check if send_interval time passed since last send */
gettimeofday(¤t_time, NULL);
timersub(¤t_time, &last_send_time, &diff_time);
send_ok = timercmp(&diff_time, &send_interval, >=);
if(more_to_send && FD_ISSET(sock, fdsw) && send_ok) {
if(targetlist) {
if(fgets(str, 80, targetlist)) {
if(!inet_aton(str, next_in_addr)) {
/* if(!inet_pton(AF_INET, str, next_in_addr)) { */
fprintf(stderr,"%s - bad IP address\n", str);
} else {
if(!in_list(scanned, ntohl(next_in_addr->s_addr)))
send_query(sock, *next_in_addr, rtt_base);
}
} else {
if(feof(targetlist)) {
more_to_send=0;
FD_ZERO(fdsw);
/* timeout is in milliseconds */
select_timeout.tv_sec = timeout / 1000;
select_timeout.tv_usec = (timeout % 1000) * 1000; /* Microseconds */
continue;
} else {
snprintf(errmsg, 80, "Read failed from file %s", filename);
err_die(errmsg, quiet);
}
}
} else if(next_address(&range, prev_in_addr, next_in_addr) ) {
if(!in_list(scanned, ntohl(next_in_addr->s_addr)))
send_query(sock, *next_in_addr, rtt_base);
prev_in_addr=next_in_addr;
/* Update last send time */
gettimeofday(&last_send_time, NULL);
} else { /* No more queries to send */
more_to_send=0;
FD_ZERO(fdsw);
/* timeout is in milliseconds */
select_timeout.tv_sec = timeout / 1000;
select_timeout.tv_usec = (timeout % 1000) * 1000; /* Microseconds */
continue;
};
};
if(more_to_send) {
FD_ZERO(fdsw);
FD_SET(sock, fdsw);
};
};
if (i>=retransmits) break; /* If we are not going to retransmit
we can finish right now without waiting */
rto = (srtt + 4 * rttvar) * (i+1);
if ( rto < 2.0 ) rto = 2.0;
if ( rto > 60.0 ) rto = 60.0;
gettimeofday(&now, NULL);
if(now.tv_sec < (transmit_started.tv_sec+rto))
sleep((transmit_started.tv_sec+rto)-now.tv_sec);
prev_in_addr = NULL ;
more_to_send=1;
FD_ZERO(fdsw);
FD_SET(sock, fdsw);
FD_ZERO(fdsr);
FD_SET(sock, fdsr);
};
delete_list(scanned);
if(buff) {
free(buff);
}
return 0;
exit(0);
};
