/* iperf_tcp_accept
*
* accept a new TCP stream connection
*/
int
iperf_tcp_accept(struct iperf_test * test)
{
int s;
signed char rbuf = ACCESS_DENIED;
char cookie[COOKIE_SIZE];
socklen_t len;
struct sockaddr_storage addr;
len = sizeof(addr);
if ((s = accept(test->listener, (struct sockaddr *) &addr, &len)) < 0) {
i_errno = IESTREAMCONNECT;
return -1;
}
if (Nread(s, cookie, COOKIE_SIZE, Ptcp) < 0) {
i_errno = IERECVCOOKIE;
close(s);
return -1;
}
if (strcmp(test->cookie, cookie) != 0) {
if (Nwrite(s, (char*) &rbuf, sizeof(rbuf), Ptcp) < 0) {
i_errno = IESENDMESSAGE;
}
else {
i_errno = IEBADCOOKIE;
}
close(s);
return -1;
}
return s;
}
/* iperf_udp_send
*
* sends the data for UDP
*/
int
iperf_udp_send(struct iperf_stream *sp)
{
int r;
uint32_t sec, usec, pcount;
int size = sp->settings->blksize;
struct timeval before;
gettimeofday(&before, 0);
++sp->packet_count;
sec = htonl(before.tv_sec);
usec = htonl(before.tv_usec);
pcount = htonl(sp->packet_count);
memcpy(sp->buffer, &sec, sizeof(sec));
memcpy(sp->buffer+4, &usec, sizeof(usec));
memcpy(sp->buffer+8, &pcount, sizeof(pcount));
r = Nwrite(sp->socket, sp->buffer, size, Pudp);
if (r < 0)
return r;
sp->result->bytes_sent += r;
sp->result->bytes_sent_this_interval += r;
return r;
}
void
Write5(DWORD d, DWORD n)
{
BYTE p[5];
Nunpack(p,n,5);
Nwrite(p,d,5);
return;
}
void main(int argc, char *argv[])
{
int skt;
int err, quit=0;
int DataBytes;
InitLib();
err=NetStart();
if(err<0)
{
Print("Init Ethernet error.\n\r");
return;
}
GetIp(MyIp);
Print("IP=%d.%d.%d.%d\r\n", MyIp[0], MyIp[1], MyIp[2], MyIp[3]);
skt=Nopen("*", "UDP/IP", 10000, 0, S_NOCON | S_NOWA);
if(skt<0)
{
Print("Cannot open a connection for UDP/IP!");
Nterm();
return;
}
Print("Socket=%d\r\n", skt);
SOCKET_NOBLOCK(skt);
while(!quit)
{
YIELD(); // must add this line in the while loop
DataBytes=Nread(skt, InBuf, 1500);
if(DataBytes>0)
{
Print("%s\n\r",InBuf);
memcpy(OutBuf, InBuf, DataBytes);
Nwrite(skt, OutBuf, DataBytes);
}
if(Kbhit())
{
switch(Getch())
{
case 'q':
case 'Q':
quit=1;
break;
}
}
}
Nclose(skt);
Nterm();
}
/* iperf_tcp_send
*
* sends the data for TCP
*/
int
iperf_tcp_send(struct iperf_stream *sp)
{
int r;
if (sp->test->zerocopy)
r = Nsendfile(sp->buffer_fd, sp->socket, sp->buffer, sp->settings->blksize);
else
r = Nwrite(sp->socket, sp->buffer, sp->settings->blksize, Ptcp);
if (r < 0)
return r;
sp->result->bytes_sent += r;
sp->result->bytes_sent_this_interval += r;
return r;
}
DWORD
RPL_CreateTemp(DWORD l)
{
DWORD a, b, c;
BYTE *p;
l += 6; // memory for link field (5) + marker (1) and end
a = Read5(TEMPTOP); // tail address of top object
b = Read5(RSKTOP); // tail address of rtn stack
c = Read5(DSKTOP); // top of data stack
if ((b+l)>c) return 0; // check if there's enough memory to move DSKTOP
Write5(TEMPTOP, a+l); // adjust new end of top object
Write5(RSKTOP, b+l); // adjust new end of rtn stack
Write5(AVMEM, (c-b-l)/5); // calculate free memory (*5 nibbles)
p = (BYTE *)malloc(b-a);
memset(p,0,b-a);
Npeek(p,a,b-a);
Nwrite(p,a+l,b-a);
free(p);
Write5(a+l-5,l); // set object length field
return (a+1); // return base address of new object
}
int
main(int argc, char **argv)
{
struct iperf_test *test;
// XXX: Setting the process affinity requires root on most systems.
// Is this a feature we really need?
#ifdef TEST_PROC_AFFINITY
/* didnt seem to work.... */
/*
* increasing the priority of the process to minimise packet generation
* delay
*/
int rc = setpriority(PRIO_PROCESS, 0, -15);
if (rc < 0) {
perror("setpriority:");
printf("setting priority to valid level\n");
rc = setpriority(PRIO_PROCESS, 0, 0);
}
/* setting the affinity of the process */
cpu_set_t cpu_set;
int affinity = -1;
int ncores = 1;
sched_getaffinity(0, sizeof(cpu_set_t), &cpu_set);
if (errno)
perror("couldn't get affinity:");
if ((ncores = sysconf(_SC_NPROCESSORS_CONF)) <= 0)
err("sysconf: couldn't get _SC_NPROCESSORS_CONF");
CPU_ZERO(&cpu_set);
CPU_SET(affinity, &cpu_set);
if (sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set) != 0)
err("couldn't change CPU affinity");
#endif
test = iperf_new_test();
if (!test) {
iperf_error("create new test error");
exit(1);
}
iperf_defaults(test); /* sets defaults */
// XXX: Check signal for errors?
signal(SIGINT, sig_handler);
if (setjmp(env)) {
if (test->ctrl_sck >= 0) {
test->state = (test->role == 'c') ? CLIENT_TERMINATE : SERVER_TERMINATE;
if (Nwrite(test->ctrl_sck, &test->state, sizeof(char), Ptcp) < 0) {
i_errno = IESENDMESSAGE;
return (-1);
}
}
exit(1);
}
if (iperf_parse_arguments(test, argc, argv) < 0) {
iperf_error("parameter error");
fprintf(stderr, "\n");
usage_long();
exit(1);
}
if (iperf_run(test) < 0) {
iperf_error("error");
exit(1);
}
iperf_free_test(test);
printf("\niperf Done.\n");
return (0);
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
ACE_SOCK_Stream connection_stream;
int c;
printf("HZ = %d\n", HZ);
if (argc < 2)
goto usage;
while ((c = getopt (argc, argv, "drstU:uvBDTb:f:l:n:p:A:O:L:xh:")) != -1)
{
switch (c)
{
case 'h':
host = optarg;
break;
case 'x':
new_line = 1;
break;
case 'L':
title = optarg;
break;
case 'B':
b_flag = 1;
break;
case 't':
trans = 1;
break;
case 'r':
trans = 0;
break;
case 'd':
options |= SO_DEBUG;
break;
case 'D':
#ifdef TCP_NODELAY
nodelay = 1;
#else
fprintf (stderr,
"ttcp: -D option ignored: TCP_NODELAY socket option not supported\n");
#endif
break;
case 'n':
nbuf = atoi (optarg);
break;
case 'l':
data_buf_len = atoi (optarg);
break;
case 's':
sinkmode = !sinkmode;
break;
case 'p':
port = atoi (optarg);
break;
case 'U':
domain = PF_UNIX;
domainname = optarg;
break;
case 'u':
udp = 1;
break;
case 'v':
verbose = 1;
break;
case 'A':
bufalign = atoi (optarg);
break;
case 'O':
bufoffset = atoi (optarg);
break;
case 'b':
#if defined(SO_SNDBUF) || defined(SO_RCVBUF)
sockbufsize = atoi (optarg);
#else
fprintf (stderr,
"ttcp: -b option ignored: SO_SNDBUF/SO_RCVBUF socket options not supported\n");
#endif
break;
case 'f':
fmt = *optarg;
break;
case 'T':
touchdata = 1;
break;
default:
goto usage;
}
}
/* if transmitter, create remote address to transmit to. */
if (trans)
{
if (address.set (port, host) == -1)
perror ("address.set"), exit (1);
}
/* else, receiver create address to listen on */
else
{
address.set (port);
}
total_msg_len = sizeof (long) + data_buf_len;
// allocate the buffer
message_buf = (Data_Control_Message *) malloc (total_msg_len);
if (message_buf == 0)
err ("malloc");
// if (bufalign != 0)
// message_buf += (bufalign - ((int) message_buf % bufalign) + bufoffset) % bufalign;
// let's go ahead and set the control message for every send right now
message_buf->size_ = data_buf_len;
session_control_buf.nbuf_ = nbuf;
session_control_buf.size_ = data_buf_len;
//
// print out option values for trans and receiver
//
if (trans)
{
fprintf (stdout,
"ttcp-t: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d",
data_buf_len, nbuf, bufalign, bufoffset, port);
if (sockbufsize)
fprintf (stdout, ", sockbufsize=%d", sockbufsize);
fprintf (stdout, " %s -> %s\n",
domain == PF_INET ? (udp ? "udp" : "tcp") : "unix",
host == 0 ? domainname : host);
}
else // receiver
{
fprintf (stdout,
"ttcp-r: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d",
data_buf_len, nbuf, bufalign, bufoffset, port);
if (sockbufsize)
fprintf (stdout, ", sockbufsize=%d", sockbufsize);
fprintf (stdout, " %s\n", domain == PF_INET ? (udp ? "udp" : "tcp") : "unix");
}
mes ("socket");
//
// connect and accept
//
if (!udp)
{
signal (SIGPIPE, (SIG_TYP) sigpipe);
/* the transmitter will set options and connect to receiver */
if (trans)
{
// turn off weird ack things
if (nodelay)
{
struct protoent *p = getprotobyname ("tcp");
if (p && connection_stream.set_option (p->p_proto,
TCP_NODELAY,
(char *)& one,
sizeof (one)))
err ("setsockopt: nodelay");
mes ("nodelay");
}
if (connector_factory.connect (connection_stream, address) == -1)
perror ("connection failed"), exit (1);
fprintf (stdout,
"ttcp-t: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d",
data_buf_len, nbuf, bufalign, bufoffset, port);
if (sockbufsize)
{
if (connection_stream.set_option (SOL_SOCKET,
SO_SNDBUF,
(char *) &sockbufsize,
sizeof sockbufsize) == -1)
err ("acceptor_factory.set_option");
mes ("sndbuf");
}
}
/* receiver will listen for connections from the transmitter */
else
{
if (acceptor_factory.open (address, 1) == -1)
perror ("acceptor open"), exit (1);
if (sockbufsize)
{
if (connection_stream.set_option (SOL_SOCKET,
SO_RCVBUF,
(char *) &sockbufsize,
sizeof sockbufsize) == -1)
err ("acceptor_factory.set_option");
mes ("rcvbuf");
}
ACE_INET_Addr remote_address;
if (acceptor_factory.accept (connection_stream,
(ACE_Addr *) &remote_address) == -1)
perror ("acceptor accept"), exit (1);
// set the window size
fprintf (stderr,
"ttcp-r: accept from %s\n",
remote_address.get_host_name());
}
}
//
// start timer
//
errno = 0;
if (trans)
{
pattern (& (message_buf->data_), data_buf_len);
prep_timer ();
ACE_DEBUG ((LM_DEBUG, "Sending session control message"
" nbuf %d, size %d\n", session_control_buf.nbuf_,
session_control_buf.size_));
if (connection_stream.send_n ((char *) &session_control_buf,
sizeof (Session_Control_Message))
!= sizeof (Session_Control_Message))
ACE_ERROR_RETURN ((LM_ERROR,
"%p send session control failed\n",
"ttcp"),
-1);
long ack;
int send_result;
while (nbuf--)
{
send_result = connection_stream.send_n ((char *) message_buf,
total_msg_len);
if (send_result != total_msg_len)
ACE_ERROR_RETURN ((LM_ERROR,
"%p only sent %d of %d bytes on call %d\n",
"ttcp", send_result, total_msg_len, numCalls + 1),
-1);
numCalls++;
nbytes += data_buf_len;
if (connection_stream.recv_n ((char *) &ack, sizeof ack) != sizeof ack)
ACE_ERROR_RETURN ((LM_ERROR, "%p recv of ack failed\n", "ttcp"), -1);
if (ack != data_buf_len)
ACE_DEBUG ((LM_DEBUG, "received ack for only %d bytes\n", ack));
}
printf("Client finished.\n");
}
else
{
prep_timer ();
if (connection_stream.recv_n ((char *) &session_control_buf,
sizeof (Session_Control_Message))
!= sizeof (Session_Control_Message))
ACE_ERROR_RETURN ((LM_ERROR,
"%p recv session control failed\n",
"ttcp"),
-1);
ACE_DEBUG ((LM_DEBUG, "received session control message"
" nbuf %d, size %d\n", session_control_buf.nbuf_,
session_control_buf.size_));
nbuf = session_control_buf.nbuf_;
// ignore session_control_buf.size_ for now
long cnt;
while (nbuf--)
{
if (connection_stream.recv_n ((char *) message_buf, sizeof (long))
!= sizeof (long))
ACE_ERROR_RETURN ((LM_ERROR,
"%p recv data control failed\n",
"ttcp"),
-1);
cnt = connection_stream.recv_n (& (message_buf->data_), message_buf->size_);
if (cnt != message_buf->size_)
ACE_ERROR_RETURN ((LM_ERROR, "recv data failed\n"), -1);
numCalls++;
nbytes += cnt;
if (connection_stream.send_n ((char *) &cnt, sizeof cnt)
!= sizeof cnt)
ACE_ERROR_RETURN ((LM_ERROR,
"%p send ack failed\n",
"ttcp"),
-1);
}
printf("Server finished.\n");
}
/* if (errno)
err ("IO");
*/
//
// stop the timer
//
(void) read_timer (stats, sizeof (stats));
if (udp && trans)
{
(void) Nwrite (connection_stream, message_buf, 4); /* rcvr end */
(void) Nwrite (connection_stream, message_buf, 4); /* rcvr end */
(void) Nwrite (connection_stream, message_buf, 4); /* rcvr end */
(void) Nwrite (connection_stream, message_buf, 4); /* rcvr end */
}
if (cput <= 0.0)
cput = 0.001;
if (realt <= 0.0)
realt = 0.001;
#if defined (LM_RESULTS)
if (trans && (title != 0))
{
double tmp;
FILE *fd;
char filename[BUFSIZ];
ACE_OS::sprintf (filename, "%s.results", title);
fd = fopen(filename,"a+");
if (new_line)
fprintf(fd,"\n -l %ldk \t", data_buf_len/1024);
tmp = ((double) nbytes) / realt;
fprintf(fd,"%.2f ", tmp * 8.0 / 1024.0 / 1024.0);
fclose(fd);
}
#endif
fprintf (stdout,
"ttcp%s: %ld bytes in %.2f real seconds = %s/sec +++\n",
trans ? "-t" : "-r",
nbytes, realt, outfmt (((double) nbytes) / realt));
if (verbose)
{
fprintf (stdout,
"ttcp%s: %ld bytes in %.2f CPU seconds = %s/cpu sec\n",
trans ? "-t" : "-r",
nbytes, cput, outfmt (((double) nbytes) / cput));
}
fprintf (stdout,
"ttcp%s: %d I/O calls, msec/call = %.2f, calls/sec = %.2f\n",
trans ? "-t" : "-r",
numCalls,
1024.0 * realt / ((double) numCalls),
((double) numCalls) / realt);
fprintf (stdout, "ttcp%s: %s\n", trans ? "-t" : "-r", stats);
if (verbose)
{
fprintf (stdout,
"ttcp%s: buffer address %#x\n",
trans ? "-t" : "-r",
message_buf);
}
exit (0);
usage:
fprintf (stderr, Usage);
return 1;
}
/* iperf_tcp_connect
*
* connect to a TCP stream listener
*/
int
iperf_tcp_connect(struct iperf_test *test)
{
struct addrinfo hints, *local_res, *server_res;
char portstr[6];
int s, opt;
int saved_errno;
if (test->bind_address) {
memset(&hints, 0, sizeof(hints));
hints.ai_family = test->settings->domain;
hints.ai_socktype = SOCK_STREAM;
if (getaddrinfo(test->bind_address, NULL, &hints, &local_res) != 0) {
i_errno = IESTREAMCONNECT;
return -1;
}
}
memset(&hints, 0, sizeof(hints));
hints.ai_family = test->settings->domain;
hints.ai_socktype = SOCK_STREAM;
snprintf(portstr, sizeof(portstr), "%d", test->server_port);
if (getaddrinfo(test->server_hostname, portstr, &hints, &server_res) != 0) {
if (test->bind_address)
freeaddrinfo(local_res);
i_errno = IESTREAMCONNECT;
return -1;
}
if ((s = socket(server_res->ai_family, SOCK_STREAM, 0)) < 0) {
if (test->bind_address)
freeaddrinfo(local_res);
freeaddrinfo(server_res);
i_errno = IESTREAMCONNECT;
return -1;
}
if (test->bind_address) {
struct sockaddr_in *lcladdr;
lcladdr = (struct sockaddr_in *)local_res->ai_addr;
lcladdr->sin_port = htons(test->bind_port);
local_res->ai_addr = (struct sockaddr *)lcladdr;
if (bind(s, (struct sockaddr *) local_res->ai_addr, local_res->ai_addrlen) < 0) {
saved_errno = errno;
close(s);
freeaddrinfo(local_res);
freeaddrinfo(server_res);
errno = saved_errno;
i_errno = IESTREAMCONNECT;
return -1;
}
freeaddrinfo(local_res);
}
/* Set socket options */
if (test->no_delay) {
opt = 1;
if (setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)) < 0) {
saved_errno = errno;
close(s);
freeaddrinfo(server_res);
errno = saved_errno;
i_errno = IESETNODELAY;
return -1;
}
}
if ((opt = test->settings->mss)) {
if (setsockopt(s, IPPROTO_TCP, TCP_MAXSEG, &opt, sizeof(opt)) < 0) {
saved_errno = errno;
close(s);
freeaddrinfo(server_res);
errno = saved_errno;
i_errno = IESETMSS;
return -1;
}
}
if ((opt = test->settings->socket_bufsize)) {
if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)) < 0) {
saved_errno = errno;
close(s);
freeaddrinfo(server_res);
errno = saved_errno;
i_errno = IESETBUF;
return -1;
}
if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) < 0) {
saved_errno = errno;
close(s);
freeaddrinfo(server_res);
errno = saved_errno;
i_errno = IESETBUF;
return -1;
}
}
if (test->debug) {
socklen_t optlen = sizeof(opt);
if (getsockopt(s, SOL_SOCKET, SO_SNDBUF, &opt, &optlen) < 0) {
saved_errno = errno;
close(s);
freeaddrinfo(server_res);
errno = saved_errno;
i_errno = IESETBUF;
return -1;
}
printf("SO_SNDBUF is %u\n", opt);
}
#if defined(HAVE_FLOWLABEL)
if (test->settings->flowlabel) {
if (server_res->ai_addr->sa_family != AF_INET6) {
saved_errno = errno;
close(s);
freeaddrinfo(server_res);
errno = saved_errno;
i_errno = IESETFLOW;
return -1;
} else {
struct sockaddr_in6* sa6P = (struct sockaddr_in6*) server_res->ai_addr;
char freq_buf[sizeof(struct in6_flowlabel_req)];
struct in6_flowlabel_req *freq = (struct in6_flowlabel_req *)freq_buf;
int freq_len = sizeof(*freq);
memset(freq, 0, sizeof(*freq));
freq->flr_label = htonl(test->settings->flowlabel & IPV6_FLOWINFO_FLOWLABEL);
freq->flr_action = IPV6_FL_A_GET;
freq->flr_flags = IPV6_FL_F_CREATE;
freq->flr_share = IPV6_FL_F_CREATE | IPV6_FL_S_EXCL;
memcpy(&freq->flr_dst, &sa6P->sin6_addr, 16);
if (setsockopt(s, IPPROTO_IPV6, IPV6_FLOWLABEL_MGR, freq, freq_len) < 0) {
saved_errno = errno;
close(s);
freeaddrinfo(server_res);
errno = saved_errno;
i_errno = IESETFLOW;
return -1;
}
sa6P->sin6_flowinfo = freq->flr_label;
opt = 1;
if (setsockopt(s, IPPROTO_IPV6, IPV6_FLOWINFO_SEND, &opt, sizeof(opt)) < 0) {
saved_errno = errno;
close(s);
freeaddrinfo(server_res);
errno = saved_errno;
i_errno = IESETFLOW;
return -1;
}
}
}
#endif /* HAVE_FLOWLABEL */
#if defined(HAVE_TCP_CONGESTION)
if (test->congestion) {
if (setsockopt(s, IPPROTO_TCP, TCP_CONGESTION, test->congestion, strlen(test->congestion)) < 0) {
close(s);
freeaddrinfo(server_res);
i_errno = IESETCONGESTION;
return -1;
}
}
#endif /* HAVE_TCP_CONGESTION */
#if defined(HAVE_SO_MAX_PACING_RATE)
/* If socket pacing is available and not disabled, try it. */
if (! test->no_fq_socket_pacing) {
/* Convert bits per second to bytes per second */
unsigned int rate = test->settings->rate / 8;
if (rate > 0) {
if (test->debug) {
printf("Socket pacing set to %u\n", rate);
}
if (setsockopt(s, SOL_SOCKET, SO_MAX_PACING_RATE, &rate, sizeof(rate)) < 0) {
warning("Unable to set socket pacing, using application pacing instead");
test->no_fq_socket_pacing = 1;
}
}
}
#endif /* HAVE_SO_MAX_PACING_RATE */
if (connect(s, (struct sockaddr *) server_res->ai_addr, server_res->ai_addrlen) < 0 && errno != EINPROGRESS) {
saved_errno = errno;
close(s);
freeaddrinfo(server_res);
errno = saved_errno;
i_errno = IESTREAMCONNECT;
return -1;
}
freeaddrinfo(server_res);
/* Send cookie for verification */
if (Nwrite(s, test->cookie, COOKIE_SIZE, Ptcp) < 0) {
saved_errno = errno;
close(s);
errno = saved_errno;
i_errno = IESENDCOOKIE;
return -1;
}
return s;
}
int
read_bin_file(char *filename)
{
struct stat st;
FILE *fp;
DWORD bin_size = 0;
BYTE *bin_buffer = (BYTE *)0;
int bBinary;
long dwAddress;
long i;
LOGI("Loading filename: %s", filename);
if (NULL == (fp = fopen(filename, "r")))
{
return 0;
}
if (stat(filename, &st) < 0)
{
fclose(fp);
return 0;
}
bin_size = st.st_size;
bin_buffer = (BYTE *)malloc(bin_size * 2);
if (fread(bin_buffer + bin_size, 1, (size_t)bin_size, fp) != bin_size)
{
free(bin_buffer);
fclose(fp);
return 0;
}
fclose(fp);
bBinary = ((bin_buffer[bin_size+0]=='H')
&& (bin_buffer[bin_size+1]=='P')
&& (bin_buffer[bin_size+2]=='H')
&& (bin_buffer[bin_size+3]=='P')
&& (bin_buffer[bin_size+4]=='4')
&& (bin_buffer[bin_size+5]=='8')
&& (bin_buffer[bin_size+6]=='-'));
for (i = 0; i < bin_size; i++)
{
BYTE byTwoNibs = bin_buffer[i+bin_size];
bin_buffer[i*2 ] = (BYTE)(byTwoNibs&0xF);
bin_buffer[i*2+1] = (BYTE)(byTwoNibs>>4);
}
if (bBinary)
{ // load as binary
bin_size = RPL_ObjectSize(bin_buffer+16);
dwAddress = RPL_CreateTemp(bin_size);
if (dwAddress == 0) return 0;
Nwrite(bin_buffer+16,dwAddress,bin_size);
}
else
{ // load as string
bin_size *= 2;
dwAddress = RPL_CreateTemp(bin_size+10);
if (dwAddress == 0) return 0;
Write5(dwAddress,0x02A2C); // String
Write5(dwAddress+5,bin_size+5); // length of String
Nwrite(bin_buffer,dwAddress+10,bin_size); // data
}
RPL_Push(dwAddress);
LOGI("Done loading filename: %s", filename);
return 1;
}
