/*

*

* TFTP Application to work with a Radiometrix Radio Module connected through serial port

* Alp Sayin

* 20.04.2012

*

*/

#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#include <termio.h>

#include <time.h>

#include <sys/fcntl.h>

#include <fcntl.h>

#include <string.h>

#include <signal.h>

#include <inttypes.h>

#include <sys/time.h>

#include <sys/select.h>

#include <stdint.h>

#include "radiotftp.h"

#include "lock.h"

#include "devtag-allinone.h"

#include "manchester.h"

#include "udp_ip.h"

#include "tftp.h"

#include "timers.h"

#include "ax25.h"

#include "util.h"

#include "datacollection.h"

#define END_OF_FILE 28

#define CTRLD 4

#define P_LOCK "/var/lock"

#define HELLO_WORLD_PORT 12345

FILE* tempFile;

char tempFileName[64];

char dial_tty[128];

const uint8_t my_ip_address[6]=

{ 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6 };

#define SYNC_LENGTH 4

const unsigned char syncword[SYNC_LENGTH]=

{ 0xAA, 0x55, 0xAA, 0x55 };

#define BYTE_ERROR_PROB 0 //0.0002 //FOR TESTING PURPOSES ONLY!!!

//reception

uint8_t command_buffer[256];

#if AX25_ENABLED==1

const uint8_t my_ax25_callsign[7]="SA0BXI\x0a";

uint8_t ax25_buffer[AX25_MAX_PAYLOAD_LENGTH + AX25_TOTAL_HEADERS_LENGTH];

uint8_t manchester_buffer[sizeof(ax25_buffer) * 2];

#else

uint8_t manchester_buffer[(UDP_MAX_PAYLOAD_LENGTH + UDP_TOTAL_HEADERS_LENGTH) * 2];

#endif

uint8_t transmit_buffer[sizeof(manchester_buffer) + 20 + SYNC_LENGTH + 2];

uint8_t udp_buffer[UDP_MAX_PAYLOAD_LENGTH + 20];

uint16_t transmit_length=0;

//transmission

#define IO_BUFSIZE 2048

uint8_t io_index=0;

uint8_t io[IO_BUFSIZE];

uint8_t buf[sizeof(manchester_buffer) + RADIOTFTP_MAX_PREAMBLE_LENGTH + SYNC_LENGTH + 2];

/* Default options */

int background=0;

long baud=-1;

int mode=-1;

int preamble_length=-1;

struct termios tp, old;

struct sigaction sa_io; //definition of signal action

struct sigaction sa_alarm;

int serialportFd;

int restore=0;

volatile uint8_t io_flag=0;

volatile uint8_t alarm_flag=0;

volatile uint8_t timer_flag=0;

volatile uint8_t queue_flag=0;

volatile uint8_t idle_flag=0;

uint8_t eth_src[6], eth_dst[6];

uint8_t udp_src[6], udp_dst[6];

uint16_t udp_src_prt, udp_dst_prt;

#if PREAMBLE_LENGTH > 15

#error preamble length cant be longer than 15

#endif

int createTempFile(char* prefix, char* postfix)

{

int length;

struct timeval curtime;

gettimeofday(&curtime, NULL);

length=sprintf(tempFileName, "%s-%ld:%ld:%ld%s\0", prefix, GMT_OFFSET + (curtime.tv_sec % (3600 * 24)) / 3600, (curtime.tv_sec % 3600) / 60, curtime.tv_sec % 60, postfix);

tempFile=fopen(tempFileName, "wb");

return length;

}

int deleteTempFile()

{

if(tempFile != NULL)

{

fflush(tempFile);

fclose(tempFile);

while(remove(tempFileName))

;

}

return 0;

}

uint8_t setRTS(uint8_t level)

{

int status;

if(level)

registerEvent("TX", "enabled");

else

registerEvent("RX", "enabled");

if(ioctl(serialportFd, TIOCMGET, &status) == -1)

{

//perror("setRTS()");

return 0;

}

if(level)

status|=TIOCM_RTS;

else

status&=~TIOCM_RTS;

if(ioctl(serialportFd, TIOCMSET, &status) == -1)

{

//perror("setRTS()");

return 0;

}

return 1;

}

TIMER_HANDLER_FUNCTION(idle_timer_handler)

{

//printf("idle timer handler\n");

idle_flag=1;

return 0;

}

void safe_exit(int retVal)

{

if(restore)

{

if(tcsetattr(serialportFd, TCSANOW, &old) < 0)

{

perror("Couldn't restore term attributes");

exit(-1);

}

}

printf("exiting...\n");

registerEvent("exit", "");

closeLogFile();

deleteTempFile();

lockfile_remove();

exit(retVal);

}

void sigINT_handler(int sig)

{

signal(sig, SIG_IGN);

safe_exit(0);

}

uint64_t signalCount=0;

void sigIO_handler(int status)

{

//fputs("sigio\n", stdout);

io_flag=1;

signalCount++;

}

void sigRTALRM_handler(int sig)

{

//printf("main timer handler\n");

timer_flag=1;

}

uint8_t queueSerialData(uint8_t* src, uint16_t src_port, uint8_t* dst, uint16_t dst_port, uint8_t* dataptr, uint16_t datalen)

{

uint16_t idx=0, len=0, j=0;

const uint8_t null_address[6]=

{ 0, 0, 0, 0, 0, 0 };

if(queue_flag)

{

return -1;

}

memset(transmit_buffer, 0x55, preamble_length);

idx+=preamble_length;

memcpy(transmit_buffer + idx, syncword, SYNC_LENGTH);

idx+=SYNC_LENGTH;

if(!memcmp(src, null_address, 6))

{

printf("WARNING! ABOUT TO SEND AN EMPTY PACKET!\n");

printf("src=");

print_addr_dec(src);

printf("src_port=%d\n", src_port);

printf("dst=");

print_addr_dec(dst);

printf("dst_port=%d\n", dst_port);

printAsciiHex(dataptr, datalen);

}

//printf("udp payload: %s\n", dataptr);

len=udp_create_packet(src, src_port, dst, dst_port, dataptr, datalen, udp_buffer);

if(len == 0)

{

fprintf(stderr, "couldn't prepare udp packet\n");

return -2;

}

#if AX25_ENABLED==1

//printf("ax25 payload: %s\n", udp_buffer);

len=ax25_create_ui_packet(ax25_get_local_callsign(NULL), ax25_get_broadcast_callsign(NULL), udp_buffer, len, ax25_buffer);

if(len == 0)

{

fprintf(stderr, "couldn't prepare ax25 packet\n");

return -3;

}

len=manchester_encode(ax25_buffer, manchester_buffer, len);

#else

len=manchester_encode(udp_buffer, manchester_buffer, len);

#endif

// transmit_buffer[idx++] = (len&0xFF); //further work

// transmit_buffer[idx++] = ((len>>8)&0xFF); //further work

memcpy(&transmit_buffer[idx], manchester_buffer, len);

idx+=len;

transmit_buffer[idx++]=END_OF_FILE;

transmit_buffer[idx++]=0;

queue_flag=1;

transmit_length=idx;

//print_time("data queued");

return 0;

}

uint16_t transmitSerialData(void)

{

uint16_t i, res=0;

int fd_flags=0;

struct sigaction save_buffer[2];

fd_flags=fcntl(serialportFd, F_GETFL);

fcntl(serialportFd, F_SETFL, O_RDWR | O_SYNC);

// tcflush(serialportFd, TCIFLUSH);

// tcflush(serialportFd, TCOFLUSH);

//

// if(tcsetattr(serialportFd, TCSANOW, &tp)<0)

// {

// perror("Couldn't set term attributes");

// return -1;

// }

sigaction(SIGALRM, NULL, save_buffer);

setRTS(1);

switch(mode)

{

case RADIOTFTP_MODE_UHF:

usleep(RADIOTFTP_BIM2A_TX_PREDELAY);

break;

case RADIOTFTP_MODE_VHF:

usleep(RADIOTFTP_UHX1_TX_PREDELAY);

break;

case RADIOTFTP_MODE_SERIAL:

usleep(RADIOTFTP_SERIAL_TX_PREDELAY);

break;

default:

perror("unknown baud rate");

safe_exit(-1);

break;

}

{

#if 0

res = write(serialportFd, transmit_buffer, transmit_length);

#else

printf("transmit_length=%d\n", transmit_length);

srand(time(NULL));

for(i=0; i < transmit_length; i++)

{

double myFloatRandom=(((float) rand()) / (float) RAND_MAX);

if(myFloatRandom < BYTE_ERROR_PROB)

{

printf("%f < %f [0x%02X]=", myFloatRandom, BYTE_ERROR_PROB, transmit_buffer[i]);

transmit_buffer[i]^=0xFF;

printf("[0x%02X]\n", transmit_buffer[i]);

}

res=write(serialportFd, transmit_buffer + i, 1);

//fprintf(stdout, "%c", io[i]);

// Potential preamble problem??

//usleep(10000);

if(res < 0)

{

printf("serial write failed\n");

return -3;

}

}

#endif

if(res < 0)

{

return -2;

}

//wait for the buffer to be flushed

tcdrain(serialportFd);

switch(mode)

{

case RADIOTFTP_MODE_UHF:

usleep(RADIOTFTP_BIM2A_TX_POSTDELAY);

break;

case RADIOTFTP_MODE_VHF:

usleep(RADIOTFTP_UHX1_TX_POSTDELAY);

break;

case RADIOTFTP_MODE_SERIAL:

usleep(RADIOTFTP_SERIAL_TX_POSTDELAY);

break;

default:

perror("unknown baud rate");

safe_exit(-1);

break;

}

}

sigaction(SIGALRM, save_buffer, NULL);

setRTS(0);

fcntl(serialportFd, F_GETFL);

fcntl(serialportFd, F_SETFL, fd_flags | O_RDWR | O_ASYNC);

// print_time("data sent");

return 0;

}

uint8_t udp_packet_demultiplexer(uint8_t* src, uint16_t src_port, uint8_t* dst, uint16_t dst_port, uint8_t* payload, uint16_t len)

{

uint8_t retVal;

// printf("== udp packet handler ==\n");

// printf("== SRC: %02x.%02x.%02x.%02x.%02x.%02x:%d ==\n", src[0], src[1], src[2], src[3], src[4], src[5], src_port);

// printf("== DST: %02x.%02x.%02x.%02x.%02x.%02x:%d ==\n", dst[0], dst[1], dst[2], dst[3], dst[4], dst[5], dst_port);

uint8_t different=0;

//check for address match

different=memcmp(udp_get_localhost_ip(NULL), dst, IPV4_DESTINATION_LENGTH);

if(different)

{

different=memcmp(udp_get_broadcast_ip(NULL), dst, IPV4_DESTINATION_LENGTH);

}

if(!different)

{

if(dst_port == 69)

{

// printf("tftp negotiate port\n");

retVal=tftp_negotiate(src, src_port, dst, dst_port, payload, len - 8);

if(retVal)

printf("tftp_negotiate(), error=%d\n", retVal);

}

else if(dst_port == tftp_transfer_src_port())

{

// printf("tftp transfer port\n");

retVal=tftp_transfer(src, src_port, dst, dst_port, payload, len - 8);

if(retVal)

printf("tftp_transfer(), error=%d\n", retVal);

}

else if(dst_port == HELLO_WORLD_PORT)

{

printf("New neighbour:\nIP = %d.%d.%d.%d\n", src[0], src[1], src[2], src[3]);

}

else

{

printf("packet received for unassigned port: %d from ", dst_port);

print_addr_dec(src);

}

}

else

{

//nothing to do here yet

//may be for routing purposes...

printf("packet for someone else: ");

print_addr_dec(dst);

printf("port: %d\n", dst_port);

}

return 0;

}

int main(int ac, char *av[])

{

//TODO extract the serial port codes into another source file, this is too ugly!

uint16_t i, j, len;

int16_t res=0, result=0;

uint8_t destination_ip[32];

uint8_t outbuf[512];

uint8_t linebuf[32];

uint8_t local_filename[32]="\0";

FILE* sptr;

if(ac == 1)

usage();

//for(i=0; i<ac; i++)

// printf("%s\n",av[i]);

if(!strcmp("uhf", av[1]))

{

mode=RADIOTFTP_MODE_UHF;

preamble_length=RADIOTFTP_BIM2A_PREAMBLE_LENGTH;

baud=RADIOTFTP_BIM2A_BAUD_RATE;

printf("Running with UHF band 19200 baud version\n");

openLogFile(RADIOTFTP_BIM2A_EVENTLOG);

}

else if(!strcmp("vhf", av[1]))

{

mode=RADIOTFTP_MODE_VHF;

preamble_length=RADIOTFTP_UHX1_PREAMBLE_LENGTH;

baud=RADIOTFTP_UHX1_BAUD_RATE;

printf("Running with VHF band 2400 baud version\n");

openLogFile(RADIOTFTP_UHX1_EVENTLOG);

}

else if(!strcmp("serial", av[1]))

{

mode=RADIOTFTP_MODE_SERIAL;

preamble_length=RADIOTFTP_SERIAL_PREAMBLE_LENGTH;

baud=RADIOTFTP_SERIAL_BAUD_RATE;

printf("Couldn't understand the uhf/vhf mode: using %d mode\n", mode);

printf("Running with NO BAND %d baud version\n", baud);

printf("Opening file %s for logging\n",RADIOTFTP_SERIAL_EVENTLOG);

openLogFile(RADIOTFTP_SERIAL_EVENTLOG);

}

else

{

printf("Mode not entered, exiting...\n");

return 0;

}

//setting defaults

udp_get_broadcast_ip(destination_ip);

strcpy(dial_tty, "/dev/ttyUSB0");

//scanning command line parameters

for(i=2; (i < ac) && (av[i][0] == '-'); i++)

{

if(strcmp(av[i], "-b") == 0)

{

background=1;

}

else if(strncmp(av[i], "-f", 2) == 0)

{

strncpy(local_filename, av[i] + 2, 32);

printf("different filename = '%s'\n", local_filename);

}

else if(strncmp(av[i], "-dst", 4) == 0)

{

memset(destination_ip, 0, 32);

memcpy(destination_ip, av[i] + 4, strlen(av[i]) - 4);

/*! convert text ip to numerical */

text_to_ip(destination_ip, strlen(av[i]) - 4 + 1);

printf("Destination: ");

print_addr_dec(destination_ip);

}

else

{

printf("unknown parameter: %s\n", av[i]);

usage();

}

}

res=0;

result=0;

strncpy(dial_tty, devtag_get(av[i]), sizeof(dial_tty));

while(!get_lock(dial_tty))

{

if(decrementLockRetries() == 0)

exit(-1);

sleep(1);

}

if((serialportFd=open(devtag_get(av[i]), O_RDWR | O_NOCTTY | O_NONBLOCK)) < 0)

{

perror("bad terminal device, try another");

exit(-1);

}

signal(SIGIO, SIG_IGN);

signal(SIGINT, sigINT_handler);

// Make the file descriptor asynchronous (the manual page says only

// O_APPEND and O_NONBLOCK, will work with F_SETFL...)

fcntl(serialportFd, F_GETFL);

fcntl(serialportFd, F_SETFL, O_RDWR | O_SYNC);

if(tcgetattr(serialportFd, &tp) < 0)

{

perror("Couldn't get term attributes");

exit(-1);

}

old=tp;

/*

SANE is a composite flag that sets the following parameters from termio(M):

CREAD BRKINT IGNPAR ISTRIP ICRNL IXON ISIG ICANON

ECHO ECHOK OPOST ONLCR

SANE also clears the following modes:

CLOCAL

IGNBRK PARMRK INPCK INLCR IUCLC IXOFF

XCASE ECHOE ECHONL NOFLSH

OLCUC OCRNL ONOCR ONLRET OFILL OFDEL NLDLY CRDLY

TABDLY BSDLY VTDLY FFDLY

*/

/* 8 bits + baud rate + local control */

tp.c_cflag=baud | CS8 | CLOCAL | CREAD;

tp.c_cflag&=~PARENB;

tp.c_cflag&=~CSTOPB;

tp.c_cflag&=~CSIZE;

tp.c_cflag|=CS8;

tp.c_cflag|=CRTSCTS;

tp.c_oflag=0; /* Raw Input */

tp.c_lflag=0; /* No conoical */

tp.c_cc[VTIME]=0;

tp.c_cc[VMIN]=1;

/* ignore CR, ignore parity */

//ISTRIP is a dangerous flag, it strips the 8th bit of bytes

//tp.c_iflag= ~( ISTRIP ) | IGNPAR | IGNBRK;

tp.c_iflag=~(IGNBRK | PARMRK | INPCK | ISTRIP | INLCR | IUCLC | IXOFF) | BRKINT | IGNPAR | ICRNL | IXON | ISIG | ICANON;

/* set output and input baud rates */

cfsetospeed(&tp, baud);

cfsetispeed(&tp, baud);

tcflush(serialportFd, TCIFLUSH);

tcflush(serialportFd, TCOFLUSH);

if(tcsetattr(serialportFd, TCSANOW, &tp) < 0)

{

perror("Couldn't set term attributes");

goto error;

}

restore=1;

//TODO go over the background codes

if(background)

{

int i;

if(getppid() == 1)

return 0; /* Already a daemon */

i=fork();

if(i < 0)

exit(1); /* error */

if(i > 0)

_exit(0); /* parent exits */

/* child */

setsid(); /* obtain a new process group */

for(i=getdtablesize(); i >= 0; --i)

{

if(i == serialportFd)

continue;

if(i == 1)

continue;

close(i); /* close all descriptors */

}

i=open("/dev/null", O_RDWR);

dup(i);

dup(i); /* handle standard I/O */

umask(027); /* set newly created file permissions */

chdir("/"); /* change running directory */

}

srand((unsigned) time(NULL));

j=0;

i++;

for(; i < ac; i++)

{

len=strlen(av[i]);

memcpy(command_buffer + j, av[i], len);

j+=len;

if(i != ac - 1)

{

command_buffer[j++]=' ';

}

}

//process the escape characters

for(i=0; i < j; i++)

{

if(command_buffer[i] == '\\')

{

if(i + 1 < j)

{

if(command_buffer[i + 1] == 'n')

{

command_buffer[i]='\r';

command_buffer[i + 1]='\n';

}

}

}

}

timers_initialize(&sigRTALRM_handler);

/*! read settings from radiotftp.conf file */

sptr=fopen("radiotftp.conf", "r");

if(sptr != NULL)

{

readnline(sptr, linebuf, 32);

linebuf[6]=atoi(linebuf + 6);

linebuf[8]=0;

printf("AX.25 Callsign: ");

print_callsign(linebuf);

#if AX25_ENABLED==1

ax25_initialize_network(linebuf);

printf("USING AX25 LINK LAYER!!!\n");

#else AX25_ENABLED==0

printf("NOT USING ANY LINK LAYER!!!\n");

#endif

readnline(sptr, linebuf, 32);

text_to_ip(linebuf, strlen(linebuf));

printf("IPv4 Address: ");

print_addr_dec(linebuf);

udp_initialize_ip_network(linebuf, &queueSerialData);

}

else

{

#if AX25_ENABLED==1

ax25_initialize_network(my_ax25_callsign);

printf("AX.25 CALLSIGN = ");

print_callsign(ax25_get_local_callsign(NULL));

#endif

udp_initialize_ip_network(my_ip_address, &queueSerialData);

printf("IPv4 Address = ");

print_addr_dec(udp_get_localhost_ip(NULL));

}

switch(mode)

{

case RADIOTFTP_MODE_UHF:

tftp_initialize(udp_get_data_queuer_fptr(), RADIOTFTP_BIM2A_ACK_TIMEOUT_MIN, RADIOTFTP_BIM2A_ACK_TIMEOUT_MAX, RADIOTFTP_BIM2A_READ_TIMEOUT);

break;

case RADIOTFTP_MODE_VHF:

tftp_initialize(udp_get_data_queuer_fptr(), RADIOTFTP_UHX1_ACK_TIMEOUT_MIN, RADIOTFTP_UHX1_ACK_TIMEOUT_MAX, RADIOTFTP_UHX1_READ_TIMEOUT);

break;

case RADIOTFTP_MODE_SERIAL:

tftp_initialize(udp_get_data_queuer_fptr(), RADIOTFTP_SERIAL_ACK_TIMEOUT_MIN, RADIOTFTP_SERIAL_ACK_TIMEOUT_MAX, RADIOTFTP_SERIAL_READ_TIMEOUT);

break;

default:

perror("unknown baud rate");

safe_exit(-1);

break;

}

if(!strncasecmp(RADIOTFTP_COMMAND_PUT, command_buffer, strlen(RADIOTFTP_COMMAND_PUT)))

{

printf(RADIOTFTP_COMMAND_PUT"\n");

registerEvent(RADIOTFTP_COMMAND_PUT, command_buffer + strlen(RADIOTFTP_COMMAND_PUT) + 1);

if((res=tftp_sendRequest(TFTP_OPCODE_WRQ, destination_ip, local_filename, command_buffer + strlen(RADIOTFTP_COMMAND_PUT) + 1, j - strlen(RADIOTFTP_COMMAND_PUT) - 1, 0)))

{

printf("%d\n", res);

perror("tftp request fail");

goto error;

}

}

else if(!strncasecmp(RADIOTFTP_COMMAND_BEACON, command_buffer, strlen(RADIOTFTP_COMMAND_BEACON)))

{

printf(RADIOTFTP_COMMAND_BEACON"\n");

registerEvent(RADIOTFTP_COMMAND_BEACON, command_buffer + strlen(RADIOTFTP_COMMAND_BEACON) + 1);

if((res=tftp_sendSingleBlockData(destination_ip, command_buffer + strlen(RADIOTFTP_COMMAND_BEACON) + 1, j - strlen(RADIOTFTP_COMMAND_BEACON) - 1, local_filename)))

{

printf("%d\n", res);

perror("tftp request fail");

goto error;

}

}

else if(!strncasecmp(RADIOTFTP_COMMAND_APPEND_LINE, command_buffer, strlen(RADIOTFTP_COMMAND_APPEND_LINE)))

{

printf(RADIOTFTP_COMMAND_APPEND_LINE"\n");

registerEvent(RADIOTFTP_COMMAND_APPEND_LINE, command_buffer + strlen(RADIOTFTP_COMMAND_APPEND_LINE) + 1);

i=createTempFile(TEMPFILE_PREFIX, TEMPFILE_POSTFIX);

if(tempFile == NULL)

{

perror("couldn't create temp file to store the line feed");

goto error;

}

fwrite(command_buffer + strlen(RADIOTFTP_COMMAND_APPEND_LINE) + 1, 1, j - strlen(RADIOTFTP_COMMAND_APPEND_LINE) - 1, tempFile);

fflush(tempFile);

fclose(tempFile);

printf("tempfileName=%s\nlocal_filename=%s\n", tempFileName, local_filename);

if((res=tftp_sendRequest(TFTP_OPCODE_WRQ, destination_ip, tempFileName, local_filename, strlen(local_filename), 1)))

{

printf("%d\n", res);

perror("tftp request fail");

goto error;

}

}

else if(!strncasecmp(RADIOTFTP_COMMAND_APPEND_FILE, command_buffer, strlen(RADIOTFTP_COMMAND_APPEND_FILE)))

{

printf(RADIOTFTP_COMMAND_APPEND_FILE"\n");

registerEvent(RADIOTFTP_COMMAND_APPEND_FILE, command_buffer + strlen(RADIOTFTP_COMMAND_APPEND_FILE) + 1);

if((res=tftp_sendRequest(TFTP_OPCODE_WRQ, destination_ip, local_filename, command_buffer + strlen(RADIOTFTP_COMMAND_APPEND_FILE) + 1, j - strlen(RADIOTFTP_COMMAND_APPEND_FILE) - 1, 1)))

{

printf("%d\n", res);

perror("tftp request fail");

goto error;

}

}

else if(!strncasecmp(RADIOTFTP_COMMAND_GET, command_buffer, strlen(RADIOTFTP_COMMAND_GET)))

{

printf(RADIOTFTP_COMMAND_GET"\n");

registerEvent(RADIOTFTP_COMMAND_GET, command_buffer + strlen(RADIOTFTP_COMMAND_GET) + 1);

if((res=tftp_sendRequest(TFTP_OPCODE_RRQ, destination_ip, local_filename, command_buffer + strlen(RADIOTFTP_COMMAND_GET) + 1, j - strlen(RADIOTFTP_COMMAND_GET) - 1, 0)))

{

printf("%d\n", res);

perror("tftp request fail");

goto error;

}

}

else

{

printf("hello radio world!\n");

registerEvent("helloWorld", "");

if((res=queueSerialData(udp_get_localhost_ip(NULL), HELLO_WORLD_PORT, udp_get_broadcast_ip(NULL), HELLO_WORLD_PORT, "hello world\n\0x00", strlen("hello world\n\0x00"))))

{

printf("%d\n", res);

perror("tftp request fail");

goto error;

}

}

int sync_counter=0;

int sync_passed=0;

int save_index=0;

//entering the main while loop

printf("started listening...\n");

while(1)

{

if(timer_flag)

{

idle_timer_handler();

tftp_timer_handler();

timer_flag=0;

}

if(idle_flag)

{

//print_time("System Idle");

idle_flag=0;

}

if(queue_flag)

{

// printf("queue flag\n");

if(!sync_passed && sync_counter < 1)

{

//wait_some

switch(mode)

{

case RADIOTFTP_MODE_UHF:

usleep(RADIOTFTP_BIM2A_TX_MESSAGE_INTERVAL);

break;

case RADIOTFTP_MODE_VHF:

usleep(RADIOTFTP_UHX1_TX_MESSAGE_INTERVAL);

break;

case RADIOTFTP_MODE_SERIAL:

usleep(RADIOTFTP_SERIAL_TX_MESSAGE_INTERVAL);

break;

default:

perror("unknown baud rate");

safe_exit(-1);

break;

}

transmitSerialData();

queue_flag=0;

}

}

if((res=read(serialportFd, io, IO_BUFSIZE)) > 0)

{

io_index=0;

//printf("# of bytes read = %d\n", res);

for(i=0; i < res; i++)

{

//putchar(io[i]);

//printf("%\n",io[i]);

if(sync_counter < SYNC_LENGTH && io[i] == syncword[sync_counter])

{

sync_counter++; /* sync continued */

//printf("sync counting %d\n",sync_counter);

}

else

{

//printf("sync reset %d\n",sync_counter);

sync_counter=0; /* not a preamble, reset counter */

}

if(sync_counter >= SYNC_LENGTH && sync_passed == 0)

{ /* preamble passed */

sync_passed=1;

}

if(sync_passed)

{

//printf("getting data '%c'\n", io[i]);

if(io[i] == END_OF_FILE && !isManchester_encoded(io[i]))

{

// printf("non-manchester character received\n");

outbuf[0]=0;

result=manchester_decode(buf + 1, manchester_buffer, save_index);

#if AX25_ENABLED==1

result=ax25_open_ui_packet(NULL, NULL, ax25_buffer, manchester_buffer, result);

#else

result=1;

#endif

if(result)

{

// printf("opened link-layer packet\n");

#if AX25_ENABLED==1

result=udp_open_packet(udp_src, &udp_src_prt, udp_dst, &udp_dst_prt, udp_buffer, ax25_buffer);

#else

result = udp_open_packet(udp_src, &udp_src_prt, udp_dst, &udp_dst_prt, udp_buffer, manchester_buffer);

#endif

if(result)

{

// printf("opened transport-layer packet\n");

udp_packet_demultiplexer(udp_src, udp_src_prt, udp_dst, udp_dst_prt, udp_buffer, result);

}

else

{

strcat(outbuf, "!udp discarded!");

if(write(1, outbuf, strlen(outbuf)) <= 0)

{

fputs("couldn't write to tty\n", stderr);

}

if(write(1, "\n", 1) <= 0)

{

fputs("couldn't write to tty\n", stderr);

}

}

}

else

{

strcat(outbuf, "!ax25 discarded!");

if(write(1, outbuf, strlen(outbuf)) <= 0)

{

fputs("couldn't write to tty\n", stderr);

}

if(write(1, "\n", 1) <= 0)

{

fputs("couldn't write to tty\n", stderr);

}

}

sync_passed=0;

sync_counter=0;

save_index=0;

}

else

{

// printf("saved data '%c'\n", io[i]);

// printf("save_index=%d/%d\n",save_index, sizeof(buf));

if(save_index >= sizeof(buf))

{

sync_passed=0;

sync_counter=0;

save_index=0;

}

buf[save_index++]=io[i];

buf[save_index + 1]=0;

// printf("-\n%s\n-\n", buf);

}

}

}

io_flag=0;

}

}

safe_exit(0);

error: safe_exit(-1);

return -2;

}