bool RnRetransmitExpiry()
{
RnRetransmit retransmit;
retransmit.add(makePacket(1), PACKET_SIZE, 100, 1);
retransmit.add(makePacket(2), PACKET_SIZE, 200, 1);
retransmit.add(makePacket(3), PACKET_SIZE, 300, 1);
retransmit.update(50);
RnAssert(retransmit.expired().empty());
retransmit.update(100);
QList<RnRetransmit::Item> items = retransmit.expired();
RnAssert(items.size() == 1);
RnAssert(items[0].packet->seq == 1);
RnAssert(items[0].timeout == 100);
RnAssert(items[0].remainingTime == 0);
RnAssert(items[0].remainingTries == 1);
retransmit.remove(items[0]);
retransmit.update(100);
items = retransmit.expired();
RnAssert(items.size() == 1);
RnAssert(items[0].packet->seq == 2);
RnAssert(items[0].timeout == 200);
RnAssert(items[0].remainingTime == 0);
RnAssert(items[0].remainingTries == 1);
retransmit.remove(items[0]);
retransmit.update(100);
items = retransmit.expired();
RnAssert(items.size() == 1);
RnAssert(items[0].packet->seq == 3);
RnAssert(items[0].timeout == 300);
RnAssert(items[0].remainingTime == 0);
RnAssert(items[0].remainingTries == 1);
retransmit.remove(items[0]);
retransmit.update(1000);
RnAssert(retransmit.expired().empty());
return true;
}
const BOOL cProxyClient::SetChannel(const DWORD dwSpace, const DWORD dwChannel)
{
if (!m_bTuner)
return FALSE;
// if ((m_dwSpace == dwSpace) && (m_dwChannel == dwChannel))
// return TRUE;
makePacket(eSetChannel2, dwSpace, dwChannel, g_ChannelLock);
m_dwResEvent[edwResSetChannel2]->Wait();
DWORD dw;
{
LOCK(m_readLock);
dw = m_dwRes[edwResSetChannel2];
}
BOOL b;
switch (dw)
{
case 0x00: // 成功
{
LOCK(m_writeLock);
TsFlush();
m_dwSpace = dwSpace;
m_dwChannel = dwChannel;
}
case 0x01: // fall-through / チャンネルロックされてる
b = TRUE;
break;
default:
b = FALSE;
break;
}
return b;
}
void quit(int sig)
{ cout << "QUIT WAS CALLED"<< endl;
MW244BPacket p;
makePacket(&p,'f',-1, updateSeqNo);
sendPacketToPlayers(p);
StopWindow();
exit(0);
}
void broadcastMessage(std::string text, IClientSocket *socket)
{
ChatPacket *packet = makePacket(text);
sendData(packet, socket);
delete packet;
}
/**********************************************
* Initilise sonar,
* check alive, send version request, check for
* reply
* returns 1 if set up, -1 if failed.
* *******************************************/
int initSonar( void )
{
int initFlag = 0, initAlive = 0;
ROS_INFO("Sonar Initilization\n");
// Check port for mtAlive
while( initFlag != 1 )
{
//Read Port
sortPacket();
//Check for mtAlive command
if( returnMsg() == mtAlive )
{
ROS_INFO("initSonar \t<< mtAlive!\n");
initAlive = 1;
//Send over the mtSendVersion
makePacket(mtSendVersion);
ROS_INFO("initSonar \t>> mtSendVersion\n");
}
// Did we get back mtVersionData and is the alive flag set?
else if( returnMsg() == mtVersionData && initAlive == 1)
{
ROS_INFO("initSonar \t<< mtVersionData!\n");
initFlag = 1;
}
else if( initAlive == 1 )
{
makePacket(mtSendVersion);
ROS_INFO("initSonar \t>> mtSendVersion\n");
}
else
{
initFlag = 0;
}
}
return 0;
}
extern "C" void scsynth_android_doOsc(JNIEnv* env, jobject classobj, jobjectArray oscMessage){
if (world->mRunning){
small_scpacket packet;
makePacket(env,oscMessage,packet);
World_SendPacket(world, packet.size(), (char*)packet.buf, androidReplyFunc);
}else{
scprintf("scsynth_android_doOsc: not running!\n");
}
}
int requestData( void )
{
int recieveFlag = 0, sendFlag = 0, headPack = 0;
while(recieveFlag != 1)
{
if(sendFlag == 0)
{
//Make the sendData packet and send
makePacket(mtSendData);
ROS_INFO("requestData \t>> mtSendData\n");
sendFlag = 1;
}
//usleep(500);
while( recieveFlag != 1)
{
sortPacket();
//if you get some data back go forth
if(returnMsg() == mtHeadData)
{
ROS_INFO("requestData \t<< mtHeadData!!\n");
headPack = 1;
}
else if(returnMsg() == mtAlive && headPack == 1)
{
recieveFlag = 1;
}
else
{
//Make the sendData packet and send
makePacket(mtSendData);
ROS_INFO("requestData \t>> mtSendData\n");
sendFlag = 1;
}
}
}
return 0;
}
BOOL cProxyClient::CreateBonDriver()
{
makePacket(eCreateBonDriver);
m_bResEvent[ebResCreateBonDriver]->Wait();
{
LOCK(m_readLock);
if (m_bRes[ebResCreateBonDriver])
m_bBonDriver = TRUE;
return m_bRes[ebResCreateBonDriver];
}
}
void sendMessage(std::string text)
{
ChatPacket *packet = makePacket(text);
// Send to your server connection
if(packet->dlen > 0 && state.enableClient == true){
state.client->Send((char*)packet, packet->plen);
}
delete packet;
}
const BOOL cProxyClient::SetLnbPower(const BOOL bEnable)
{
if (!m_bTuner)
return FALSE;
makePacket(eSetLnbPower, bEnable);
m_bResEvent[ebResSetLnbPower]->Wait();
{
LOCK(m_readLock);
return m_bRes[ebResSetLnbPower];
}
}
const DWORD cProxyClient::GetActiveDeviceNum(void)
{
if (!m_bTuner)
return 0;
makePacket(eGetActiveDeviceNum);
m_dwResEvent[edwResGetActiveDeviceNum]->Wait();
{
LOCK(m_readLock);
return m_dwRes[edwResGetActiveDeviceNum];
}
}
LPCTSTR cProxyClient::EnumChannelName(const DWORD dwSpace, const DWORD dwChannel)
{
if (!m_bTuner)
return NULL;
makePacket(eEnumChannelName, dwSpace, dwChannel);
m_pResEvent[epResEnumChannelName]->Wait();
{
LOCK(m_readLock);
return m_pRes[epResEnumChannelName];
}
}
void cProxyClient::Release(void)
{
if (m_bTuner)
CloseTuner();
makePacket(eRelease);
m_bRereased = TRUE;
{
LOCK(Lock_Global);
InstanceList.remove(this);
}
delete this;
}
BOOL cProxyClient::SelectBonDriver()
{
{
LOCK(Lock_Global);
makePacket(eSelectBonDriver, g_BonDriver);
}
m_bResEvent[ebResSelectBonDriver]->Wait();
{
LOCK(m_readLock);
return m_bRes[ebResSelectBonDriver];
}
}
const BOOL cProxyClient::OpenTuner(void)
{
if (!m_bBonDriver)
return FALSE;
makePacket(eOpenTuner);
m_bResEvent[ebResOpenTuner]->Wait();
{
LOCK(m_readLock);
if (m_bRes[ebResOpenTuner])
m_bTuner = TRUE;
return m_bRes[ebResOpenTuner];
}
}
void HttpPoll::connectToHost(const QString &proxyHost, int proxyPort, const QUrl &url)
{
resetConnection(true);
bool useSsl = false;
d->port = 80;
// using proxy?
if(!proxyHost.isEmpty()) {
d->host = proxyHost;
d->port = proxyPort;
d->url = url;
d->use_proxy = true;
}
else {
d->host = url.host();
if(url.port() != -1)
d->port = url.port();
else if (url.scheme() == "https") {
d->port = 443;
useSsl = true;
}
#if QT_VERSION < 0x050000
d->url = url.path() + "?" + url.encodedQuery();
#else
d->url.setUrl(url.path() + "?" + url.query(QUrl::FullyEncoded), QUrl::StrictMode);
#endif
d->use_proxy = false;
}
resetKey();
bool last;
QString key = getKey(&last);
#ifdef PROX_DEBUG
fprintf(stderr, "HttpPoll: Connecting to %s:%d [%s]", d->host.latin1(), d->port, d->url.latin1());
if(d->user.isEmpty())
fprintf(stderr, "\n");
else
fprintf(stderr, ", auth {%s,%s}\n", d->user.latin1(), d->pass.latin1());
#endif
QPointer<QObject> self = this;
syncStarted();
if(!self)
return;
d->state = 1;
d->http.setUseSsl(useSsl);
d->http.setAuth(d->user, d->pass);
d->http.post(d->host, d->port, d->url, makePacket("0", key, "", QByteArray()), d->use_proxy);
}
void respondToClient(struct ClientNode *client, HeaderFlag flag, uint8_t *data, ssize_t dataLen)
{
struct ChatHeader responseHeader;
responseHeader.sequenceNumber = ntohl(client->packetData->sequenceNumber);
responseHeader.checksum = ntohs(client->packetData->checksum);
responseHeader.flag = flag;
uint8_t *packet = makePacket(responseHeader, data, dataLen);
ssize_t packetLength = kChatHeaderSize + dataLen;
ssize_t bytesSent;
if ((bytesSent = sendErr(client->clientSocket, packet, packetLength, 0)) < 0) {
perror("respondToClient:send");
}
free(packet);
}
void remoteMessage(std::string text, IClientSocket *socket, bool wait)
{
ChatPacket *packet = makePacket(text);
if(packet->dlen > 0)
{
// No remote socket specified, send message to the server
if(socket == NULL) socket = state.client;
// Send message
socket->Send((char *)packet, packet->plen, wait);
}
delete packet;
}
cProxyClient::~cProxyClient()
{
if (!m_bRereased)
{
if (m_bTuner)
CloseTuner();
makePacket(eRelease);
}
m_Error.Set();
// if (m_iEndCount != -1)
// SleepLock(3);
if (m_hThread != 0)
::pthread_join(m_hThread, NULL);
int i;
{
LOCK(m_writeLock);
for (i = 0; i < 8; i++)
{
if (m_pBuf[i] != NULL)
delete[] m_pBuf[i];
}
::memset(m_pBuf, 0, sizeof(m_pBuf));
TsFlush();
if (m_LastBuff != NULL)
{
delete m_LastBuff;
m_LastBuff = NULL;
}
}
for (i = 0; i < ebResNum; i++)
delete m_bResEvent[i];
for (i = 0; i < edwResNum; i++)
delete m_dwResEvent[i];
for (i = 0; i < epResNum; i++)
delete m_pResEvent[i];
::pthread_cond_destroy(&m_c);
::pthread_mutex_destroy(&m_m);
if (m_s != INVALID_SOCKET)
::close(m_s);
}
void cProxyClient::PurgeTsStream(void)
{
if (!m_bTuner)
return;
makePacket(ePurgeTsStream);
m_bResEvent[ebResPurgeTsStream]->Wait();
BOOL b;
{
LOCK(m_readLock);
b = m_bRes[ebResPurgeTsStream];
}
if (b)
{
LOCK(m_writeLock);
TsFlush();
}
}
void cProxyClient::CloseTuner(void)
{
if (!m_bTuner)
return;
makePacket(eCloseTuner);
m_bTuner = FALSE;
m_fSignalLevel = 0;
m_dwSpace = m_dwChannel = 0xff;
{
LOCK(m_writeLock);
m_dwBufPos = 0;
for (int i = 0; i < 8; i++)
{
if (m_pBuf[i] != NULL)
delete[] m_pBuf[i];
}
::memset(m_pBuf, 0, sizeof(m_pBuf));
}
}
void Communicator::getPacket() {
if (index == 0) {
int rd = this->readBytes(buffer, 1);
if (rd > 0) {
size = buffer[0];
index = 1;
}
} else {
int rd = this->readBytes(buffer + index, 1 + size - index);
if (rd > 0) {
index += rd;
if (index == size + 1) {
makePacket();
for (unsigned int i = 0; i < index; i++) {
buffer[i] = 0;
}
index = 0;
}
}
}
}
int sendBB( void )
{
int bbFlag = 0;
while( bbFlag != 1 )
{
if( returnMsg() == mtBBUserData )
{
ROS_INFO("sendBB \t<< mtBBUserData!\n");
bbFlag = 1;
}
else
{
makePacket(mtSendBBUser);
ROS_INFO("sendBB \t>> mtSendBBUser\n");
}
}
return 0;
}
void HttpPoll::do_sync()
{
if(d->http.isActive())
return;
d->t->stop();
d->out = takeWrite(0, false);
bool last;
QString key = getKey(&last);
QString newkey;
if(last) {
resetKey();
newkey = getKey(&last);
}
QPointer<QObject> self = this;
syncStarted();
if(!self)
return;
d->http.post(d->host, d->port, d->url, makePacket(d->ident, key, newkey, d->out), d->use_proxy);
}
/**
* Currently we assume that a message is either
* 1. A primitive (strings, ints, etc) message
* 2. A bundle of other messages
* There is no provision for the situation where a message contains both
* primitive and bundle data, but you can bundle bundles
*/
void makePacket(JNIEnv* env, jobjectArray oscMessage, small_scpacket& packet,int start=0) {
int numElements = env->GetArrayLength(oscMessage);
#ifndef NDEBUG
scprintf("received a message with %i elements\n",numElements);
#endif
if (numElements<=0) return; // No message
int i;
jobject obj;
const char* stringPtr;
jclass integerClass = env->FindClass("java/lang/Integer");
jmethodID getIntMethod = env->GetMethodID(integerClass,"intValue","()I");
jclass floatClass = env->FindClass("java/lang/Float");
jmethodID getFloatMethod = env->GetMethodID(floatClass,"floatValue","()F");
jclass stringClass = env->FindClass("java/lang/String");
jclass oscClass = env->FindClass(OSC_MESSAGE_CLASS);
jmethodID toArrayMethod = env->GetMethodID(oscClass,"toArray","()[Ljava/lang/Object;");
obj = env->GetObjectArrayElement(oscMessage,0);
if (env->IsInstanceOf(obj,oscClass)) {
#ifndef NDEBUG
scprintf("it's a bundle!\n");
#endif
packet.OpenBundle(0);
while (start<numElements) {
obj = env->GetObjectArrayElement(oscMessage,start);
jobjectArray bundle = (jobjectArray) env->CallObjectMethod(obj,toArrayMethod);
#ifndef NDEBUG
scprintf("making a new packet %i\n",start);
#endif
packet.BeginMsg();
makePacket(env, bundle, packet);
packet.EndMsg();
++start;
}
packet.CloseBundle();
} else if (env->IsInstanceOf(obj,stringClass)) {
stringPtr = env->GetStringUTFChars((jstring)obj,NULL);
packet.adds(stringPtr);
#ifndef NDEBUG
scprintf("cmd %s\n",stringPtr);
#endif
env->ReleaseStringUTFChars((jstring)obj,stringPtr);
packet.maketags(numElements);
packet.addtag(',');
for (i=1;i<numElements;++i) {
obj = env->GetObjectArrayElement(oscMessage,i);
if (env->IsInstanceOf(obj,integerClass)) {
packet.addtag('i');
packet.addi(env->CallIntMethod(obj,getIntMethod));
} else if (env->IsInstanceOf(obj,floatClass)) {
packet.addtag('f');
packet.addf(env->CallFloatMethod(obj,getFloatMethod));
} else if (env->IsInstanceOf(obj,stringClass)) {
packet.addtag('s');
stringPtr = env->GetStringUTFChars((jstring)obj,NULL);
#ifndef NDEBUG
scprintf("arg %s\n",stringPtr);
#endif
packet.adds(stringPtr);
env->ReleaseStringUTFChars((jstring)obj,stringPtr);
}
}
}
}
int requestData( void )
{
int recieveFlag = 0, sendFlag = 0, headPack = 0;
int count;
while(recieveFlag != 1)
{
if(sendFlag == 0)
{
//Make the sendData packet and send
// tcflush(fd, TCIFLUSH);//remove
// usleep(50);//remove
// tcflush(fd, TCIFLUSH);//remove
// usleep(50);//remove
makePacket(mtSendData);
// ROS_INFO("requestData \t>> mtSendData\n");
//tcflush(fd, TCIFLUSH);//remove
//usleep(50);//remove
sendFlag = 1;
}
//usleep(500);
count = 0;
while( recieveFlag != 1)
{
sortPacket();
//if you get some data back go forth
if(returnMsg() == mtHeadData)
{
// ROS_INFO("requestData \t<< mtHeadData!!\n");
headPack = 1;
return 0;
}
else if(returnMsg() == mtAlive && headPack == 1)
{
recieveFlag = 1;
//tcflush(fd, TCIFLUSH);//remove
}
else
{
if(count > 10)
{
//Make the sendData packet and send
// tcflush(fd, TCIFLUSH);//remove
// usleep(500);//remove
makePacket(mtSendData);
ROS_INFO("requestData \t>> mtSendData\n");
sendFlag = 1;
count = 0;
}
count ++;
//printf("%d\n", count);
}
}
}
return 0;
}
ServiceClient()
{
register IOBUFFER *iop = &InputBuffer[0];
int n,m;
char *ptr, *net;
if((iop->inputbuf = (char *) xalloc(BUFSIZE)) == NULL)
{
SendNull();
return;
}
iop->buflen = BUFSIZE;
if(!Read(0, iop->inputbuf, HEADERSIZE))
{
fprintf(stderr, "Cannot read the HEADERSIZE\n");
SendNull();
return(-1);
}
iop->bufptr = HEADERSIZE;
iop->msglen = *(int *) iop->inputbuf;
if(iop->buflen < iop->msglen)
{
iop->inputbuf = (char *) xrealloc(iop->inputbuf, iop->msglen);
if( iop->inputbuf == NULL)
{
SendNull();
return;
}
iop->buflen = iop->msglen;
}
if(!Read(0, &iop->inputbuf[iop->bufptr], iop->msglen - iop->bufptr))
{
fprintf(stderr, "Cannot read the rest of the message\n");
SendNull();
return(-1);
}
ptr = &iop->inputbuf[sizeof(int)];
m = *(int *) ptr;
ptr += sizeof(int);
flags = *(int *) ptr;
ptr += sizeof(int);
dispno = *(int *) ptr;
ptr += sizeof(int);
n = *(int *) ptr;
ptr += sizeof(int);
net = ptr;
ptr = &iop->inputbuf[m];
inlen = *(int *) ptr;
ptr += sizeof(int);
nhosts = *(int *) ptr;
inbuf = ptr + sizeof(int);
TheEnd = &inbuf[inlen];
#ifdef DEBUG
write(2, inbuf, inlen);
#endif
nextentry = ((xHostEntry *) inbuf)->length;
if((ptr = (char *) makePacket()) != NULL)
{
#ifdef DEBUG1
write(2, ptr, (*(int *) ptr) + 2*sizeof(int));
#endif
write(1, ptr, (*(int *) ptr) + 2*sizeof(int));
}
return(1);
}
//파일을 보내는 함수. 이 함수를 스레드를 이용해 병렬적으로 실행시킨다. 클라이언트는 이때 파일을 받는 함수를 실행해야 함.
void* SendData(void* p)
{
int nread; //데이터의 크기
char file_buffer[MAX_BUFFER]; //데이터를 담을 버퍼
char ACK_buffer[8] = {0, }; //ACK 응답을 담을 버퍼. "ACK" + int 의 7바이트를 담을 수 있도록
char* ACKWindow = NULL; //ACK 처리여부 윈도우. 최대 (블록 크기(B) * 윈도우) 크기 정도의 용량 전송
//이 윈도우는 처음에 0으로 초기화, ACKWindow[n]이 1이 된다는 것은
//ACK(n)을 받았다는 것으로 인식한다.
FILE* f; //보낼 파일의 디스크립터
int ACKresult; //ACK 읽어본 후 결과값
int filesize; //파일의 크기. 이것도 상대에게 보냄
int currentSend = 0; //지금까지 보낸 파일의 크기
int retcode;
int nextSeq = 0; //이제 보내야 할 부분 seq 인덱스
time_t lastTime;
time_t currentTime; //1초마다 상황 출력을 위해 사용할 시간 변수
/*======매개변수 p(threadArgs 구조채)의 정보에서 소켓과 클라이언트 정보를 가져온다=====*/
threadArgs* args = (threadArgs*)p;
int socketDes;
char fname[MSGLEN];
struct sockaddr_in clientAddr;
socklen_t client_addr_size;
int* threadIdx = NULL;
socketDes = args->dataSocketDes;
strcpy(fname, args->fname);
clientAddr = args->dataAddr;
client_addr_size = args->data_addr_size;
threadIdx = args->threadIdx;
/*===================================================================================*/
//ACK 윈도우는 각 seq num에 대응된다. ACKWindow[5]는 seq 5를 의미.
//이를 0으로 초기화하였다.
ACKWindow = (char*)calloc(MAX_WINDOW, sizeof(char));
if((f = fopen(fname, "rb")) == NULL)
exit(1);
//파일의 크기를 보낸다.
fseek(f, 0L, SEEK_END); //일단 파일 끝 부분으로 포인터 이동
filesize = ftell(f); //그 포인터 값이 바로 파일 크기이다.
fseek(f, 0L, SEEK_SET); //다시 파일 처음 부분으로 포인터 이동
memcpy((int*)(file_buffer), &filesize, 4); //파일 크기를 보냄
nread = makePacket(nextSeq, 4, file_buffer); //앞에 0 seq을 넣어보냄.
//동기화를 위한 수신 함수. 그 외에는 아무 의미 없다.
nread = recvfrom(socketDes, ACK_buffer, 8, 0, (struct sockaddr*)&clientAddr, &client_addr_size);
//파일 크기를 보낸다.
nread = sendto(socketDes, file_buffer, nread, 0, (struct sockaddr*)&clientAddr, sizeof(clientAddr));
//이때는 ACK 0의 대답을 받아내야 한다.
//ACK(n) 메시지는 7바이트로 가정. ("ACK" 3바이트 + n은 정수 4바이트)
while(ACKWindow[nextSeq] == 0)
{
//!!!rcvfrom은 데이터를 받을 때까지 대기한다.
nread = recvfrom(socketDes, ACK_buffer, 8, 0, (struct sockaddr*)&clientAddr, &client_addr_size);
ACKresult = extractACK(ACK_buffer);
//상대방이 보낸 ACK를 읽어들인다. 0을 얻어야 한다.
if(ACKresult == nextSeq)
{
//원하는 ACK(n)이었다면 window[0] 확인. 다음 seq 준비
ACKWindow[nextSeq] = 1;
nextSeq++;
break;
}
else retransfer();
}
time(&lastTime);
while(!feof(f))
{
file_buffer[0] = '\0';
nread = fread(file_buffer, 1, DATA_BLOCK, f);
//파일에서 DATA_BLOCK(200)바이트 정도를 파일 버퍼로 가져온다.
nread = makePacket(nextSeq, nread, file_buffer); //앞에 1, 2, ..n seq을 넣어보냄.
//현 시간 - 아까 기록한 시간의 차가 1 이상이면 1초가 흐른 것으로 간주.
if((time(¤tTime) - lastTime) >= 1)
{
printf("Transfer status : send[%s][%d%c , %f MB / %f MB]\n", fname, (int)((double)currentSend * 100 /filesize),'%', (double)currentSend/1000000, (double)filesize/1000000);
time(&lastTime);
}
while(ACKWindow[nextSeq] == 0)
{
//데이터를 보낸다.
nread = sendto(socketDes, file_buffer, nread, 0, (struct sockaddr*)&clientAddr, sizeof(clientAddr));
currentSend += (nread - 4);
//파일을 보냈으니 이젠 대답을 기다린다.
nread = recvfrom(socketDes, ACK_buffer, 8, 0, (struct sockaddr*)&clientAddr, &client_addr_size);
ACKresult = extractACK(ACK_buffer);
if(ACKresult == nextSeq)
{
ACKWindow[nextSeq] = 1;
nextSeq++;
break;
}
else retransfer();
}
}
fclose(f);
//파일이 모두 전송되었다면 파일이 끝났다는 메세지를 보낸다.
printf("Successfully transferred.\n");
strcpy(file_buffer, "endoffile");
sendto(socketDes, file_buffer, strlen("endoffile"), 0, (struct sockaddr*)&clientAddr, sizeof(clientAddr));
//윈도우 반환
free(ACKWindow);
//이제 데이터 전송 스레드가 끝났다면, 스레드 수를 감소시킨다.
//threadIdx는 위 commandProcessing 함수 안의 지역변수이다.
(*threadIdx) = (*threadIdx) - 1;
//서버는 데이터 전송 소켓을 여기서 닫는다.
close(socketDes);
return;
}
//============================================================================
int main(int argc, char *argv[]) {
#ifndef WIN32
signal(SIGINT, exitProgram);
signal(SIGTERM, exitProgram);
signal(SIGHUP, exitProgram);
signal(SIGKILL, exitProgram);
#endif
timestamp = updateTimestamp();
// Set Default values
sendRate = 1.0;
strcpy(missionId, "Mission 01");
strcpy(platform, "Demo");
latitude = (uint32_t)htonl(mapLatitude("44.64423"));
longitude = (uint32_t)htonl(mapLongitude("-93.24013"));
altitude = (uint16_t)htons(mapAltitude("333"));
strcpy(address, "127.0.0.1");
servPort = 9000;
DEBUG = 0;
printf("\nUDP Generator, Version 1.0.1\nKevan Ahlquist\nAll Rights Reserved\n\n");
// read user options
int option_index = 0;
char optc;
static struct option long_options[] =
{
{"address", required_argument, 0, 'a'},
{"port", required_argument, 0, 'p'},
{"rate", required_argument, 0, 'r'},
{"mission-id", required_argument, 0, 'm'},
{"platform", required_argument, 0, 'n'},
{"latitude", required_argument, 0, 't'},
{"longitude", required_argument, 0, 'g'},
{"altitude", required_argument, 0, 'e'},
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
{0, 0, 0, 0}
};
while (( optc = getopt_long(argc, argv, "a:p:r:m:n:t:g:e:hv", long_options, &option_index)) != -1) {
switch(optc) {
case 'a':
strncpy(address, optarg, 16);
address[15] = '\0'; // Prevent buffer overrun
printf("Address received: %s\n", address);
break;
case 'p':
servPort = atol(optarg);
printf("Port received: %d\n", servPort);
break;
case 'r':
sendRate = atof(optarg);
printf("Rate received: %f\n", sendRate);
if (sendRate > 1000000) {
printf("Values greater than 1,000,000 packets per second are not supported\n");
exit(0);
}
break;
case 'm':
strncpy(missionId, optarg, 12);
missionId[12] = '\0'; // Prevent buffer overrun
if (strlen(optarg) > 12) printf("WARNING: Mission ID truncated to 12 characters\n");
printf("Mission ID received: %s\n", missionId);
break;
case 'n':
strncpy(platform, optarg, 12);
platform[12] = '\0'; // Prevent buffer overrun
if (strlen(optarg) > 12) printf("WARNING: Platform truncated to 12 characters\n");
printf("Platform received: %s\n", platform);
break;
case 't':
latitude = (uint32_t)htonl(mapLatitude(optarg));
printf("Latitude received: %s\n", optarg);
if (atof(optarg) < -90.0 || atof(optarg) > 90.0) {
printf("ERROR: Latitude out of range (-90,90)\n");
exit(0);
}
break;
case 'g':
longitude = (uint32_t)htonl(mapLongitude(optarg));
printf("Longitude received: %s\n", optarg);
if (atof(optarg) < -180.0 || atof(optarg) > 180.0) {
printf("ERROR: Longitude out of range (-180,180)\n");
exit(0);
}
break;
case 'e':
altitude = (uint16_t)htons(mapAltitude(optarg));
printf("Altitude received: %s\n", optarg);
if (atof(optarg) < -900 || atof(optarg) > 19000) {
printf("ERROR: Altitude out of range(-900,19000)\n");
exit(0);
}
break;
case 'h':
help();
exit(0);
break;
case 'v':
exit(0);
break;
default:
printf("Usage: klvgen -a <address>:<port> -r <rate> -m<mission-id> -p <platform> -t <lat> -g <long> -e <elev>\n");
printf("For help use option -h or --help\n");
exit(0);
}
}
if (udpInit() == -1) exit(-1);
// TESTING ================================================================
int i;
if (DEBUG) {
printf("Testing mapping functions===============\n");
printf("map 0 from 0-10 to 0-100: %d\n", mapValue(0,0,10,0,100));
printf("map 10 from 0-10 to 0-100: %d\n", mapValue(10,0,10,0,100));
printf("map 5 from 0-10 to 0-100: %d\n", mapValue(5,0,10,0,100));
}
if (DEBUG) {
printf("uasLdsKey:\n");
for (i = 0; i < 16; ++i) {
printf("%X", uasLdsKey[i]);
}
printf("\n");
#ifdef WIN32
printf("Timestamp (truncated): %u\n", (unsigned int)timestamp);
#else
printf("Timestamp: %llu\n", timestamp);
#endif
}
if (DEBUG) {
printf("Testing makePacket, packetBuffer:\n");
printf(" K L Value...\n");
makePacket(packetBuffer);
for (i = 0; i < 80; ++i) {
printf("%2X ", packetBuffer[i]);
if ((i == 15) || (i == 25) || (i == 39) || (i == 53) || (i == 59) || (i == 65) || (i == 69) || (i == 72)) {
printf("\n");
}
}
printf("\n");
udpSendPacket((const char *)packetBuffer);
}
if (DEBUG) {
printf("Testing htonll function:\n num: 0x 01 02 03 04 05 06 07 08\n");
uint64_t number = 0x0102030405060708ULL;
uint64_t num2 = htonll(number);
printf("number: ");
printf("%2X ", (char)(number & 0xFF));
printf("%2X ", (char)((number & 0xFF00) >> 8));
printf("%2X ", (char)((number & 0xFF0000) >> 16));
printf("%2X ", (char)((number & 0xFF000000) >> 24));
printf("%2X ", (char)((number & 0xFF00000000ULL) >> 32));
printf("%2X ", (char)((number & 0xFF0000000000ULL) >> 40));
printf("%2X ", (char)((number & 0xFF000000000000ULL) >> 48));
printf("%2X ", (char)((number & 0xFF00000000000000ULL) >> 56));
printf("\n");
printf("num2: ");
printf("%2X ", (char)(num2 & 0xFF));
printf("%2X ", (char)((num2 & 0xFF00) >> 8));
printf("%2X ", (char)((num2 & 0xFF0000) >> 16));
printf("%2X ", (char)((num2 & 0xFF000000) >> 24));
printf("%2X ", (char)((num2 & 0xFF00000000ULL) >> 32));
printf("%2X ", (char)((num2 & 0xFF0000000000ULL) >> 40));
printf("%2X ", (char)((num2 & 0xFF000000000000ULL) >> 48));
printf("%2X ", (char)((num2 & 0xFF00000000000000ULL) >> 56));
printf("\n");
}
// END TESTING==========================================================
while (1) {
timestamp = htonll(updateTimestamp());
makePacket(packetBuffer);
udpSendPacket((const char *)packetBuffer);
if (DEBUG) {
printf("\n K L Value...\n");
for (i = 0; i < 80; ++i) {
printf("%2X ", packetBuffer[i]);
if ((i == 16) || (i == 26) || (i == 40) || (i == 54) ||
(i == 60) || (i == 66) || (i == 70) || (i == 73)) {
printf("\n");
}
}
}
#ifdef WIN32
Sleep((1 / sendRate) * 1000);
#else
usleep((1 / sendRate) * 1000); // usleep is untested, may not compile
#endif
}
}
Packet parseSentence(const std::string &sentence) {
auto elems = tokenizeSentence(sentence);
auto p = makePacket(elems);
return p;
}
