void init() {
interrupts::setIrqHandler(1, [](interrupts::Registers*) {
scancodeQueue.enqueue(ports::inb(0x60));
});
flushBuffer();
}
void *udpSock(void *param)
{
PRINTD(1,"udpSock: udpSock started\n");
#ifdef WIN32
int first = 1;
#endif
HANDLE hComm = 0;
paramThread *paraThread;
paraThread = (paramThread *) param;
int sock = 0;
unsigned char payload[MAX_PAYLOAD_SIZE];
struct info *infos = (struct info *) calloc(logbuffer_size, sizeof(info));
struct addrinfo SrcAddress;
in_port_t tmpPort = 0;
int size_r = 0;
unsigned char *ptrSeqNum = payload + sizeof(uint32_t);
unsigned char *ptrTimeSec = ptrSeqNum + sizeof(uint32_t);
unsigned char *ptrTimeUsec = ptrTimeSec + sizeof(uint32_t);
struct timeval RcvTime;
#ifdef WIN32
LARGE_INTEGER _tstart, _tend;
unsigned long secs = 0, msecs = 0;
#endif
paraThread->addressInfos = infos;
paraThread->count = 0;
if (strcmp(paraThread->serial, "noSerial") != 0) {
hComm = serialUp(paraThread->serial);
if (hComm == INVALID_HANDLE_VALUE)
printf("Error opening interface %s \n", paraThread->serial);
}
bool socketAlreadyOpen = false;
#ifdef MULTIPORT
if ((passiveMode == false) && (paraThread->indexPort > 0))
{
MUTEX_THREAD_LOCK(sharedUdpSockets[paraThread->indexPort].mutexSharedSockets);
sock = sharedUdpSockets[paraThread->indexPort].socket;
if (sock > 0)
{
socketAlreadyOpen = true;
}
}
#endif
if (socketAlreadyOpen == false) {
sock = socket(paraThread->destHost.ai_family, SOCK_DGRAM, 0);
if (paraThread->dsByte
&& (paraThread->destHost.ai_family == AF_INET)
&& setsockopt(sock, SOL_IP, IP_TOS, (char *) ¶Thread->dsByte, sizeof(BYTE)) < 0) {
printf("** WARNING ** Flow %d. Could not set DS byte to: %d\n", paraThread->flowId, paraThread->dsByte);
}
}
if (sock < 0)
reportErrorAndExit("udpSock", "socket", "Cannot create a DATAGRAM socket on port");
if ((passiveMode == false) && (socketAlreadyOpen == false))
{
if (bind(sock, paraThread->destHost.ai_addr, paraThread->destHost.ai_addrlen) < 0) {
printf("Error into bind function!\n");
struct pipeMsg msg;
msg.code = MSG_FT_ERR1;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf(" sending msg error");
}
sleep(INFINITE);
}
else
{
#ifdef WIN32
int len=paraThread->destHost.ai_addrlen;
getsockname(sock,paraThread->destHost.ai_addr,&len);
paraThread->destHost.ai_addrlen=len;
#else
getsockname(sock, paraThread->destHost.ai_addr, &(paraThread->destHost.ai_addrlen));
#endif
GET_PORT((&(paraThread->destHost)), tmpPort);
fprintf(stderr, "Listening on UDP port : %d\n", ntohs(tmpPort));
fflush(stderr);
#ifdef MULTIPORT
if (paraThread->indexPort == 0)
{
paraThread->indexPort = ntohs(tmpPort);
MUTEX_THREAD_LOCK(sharedUdpSockets[paraThread->indexPort].mutexSharedSockets);
}
#endif
struct pipeMsg msg;
msg.code = MSG_FT_OK;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf("error sending msg to signal manager");
}
}
}
else if (passiveMode == true) {
struct addrinfo *addrForListen = NULL;
//#if (defined WIN32 && defined IPv6RECV) || defined UNIX || defined BSD
if (paraThread->destHost.ai_family == PF_INET6) {
getaddrinfo("::", NULL, &hint, &addrForListen);
} else
//#endif
{
getaddrinfo("0.0.0.0", NULL, &hint, &addrForListen);
}
SET_PORT((addrForListen), htons((paraThread->portForPssv)));
if (bind(sock, addrForListen->ai_addr, addrForListen->ai_addrlen) < 0) {
struct pipeMsg msg;
msg.code = MSG_FT_ERR1;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf(" sending msg error");
}
sleep(INFINITE);
} else {
GET_PORT(( addrForListen), tmpPort);
printf("Listening on UDP port : %d\n", ntohs(tmpPort));
fflush(stdout);
for (int x = 0; x < numHolePkt; x++) {
if (sendto(sock, "hello", sizeof("hello"), 0, paraThread->destHost.ai_addr,
paraThread->destHost.ai_addrlen) < 0) {
reportErrorAndExit("udpSock", "sendto", "Cannot sendto (Passive Mode --> Hole punching)");
}
}
}
if (connect(sock, paraThread->destHost.ai_addr, paraThread->destHost.ai_addrlen) < 0) {
reportErrorAndExit("udpSock", "connect", "Cannot connect (Passive Mode)");
}
freeaddrinfo(addrForListen);
}
#ifdef MULTIPORT
else if ((passiveMode == false) && (socketAlreadyOpen == true)) {
struct pipeMsg msg;
msg.code = MSG_FT_OK;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf("error sending msg to signal manager");
}
}
if (passiveMode == false) {
if (socketAlreadyOpen == false) {
sharedUdpSockets[paraThread->indexPort].socket = sock;
}
sharedUdpSockets[paraThread->indexPort].inUse++;
MUTEX_THREAD_UNLOCK(sharedUdpSockets[paraThread->indexPort].mutexSharedSockets);
}
#endif
//#if defined UNIX && ! defined BSD
if ((paraThread->iface) && (socketAlreadyOpen == false)) {
printf("Binding to device %s\n", paraThread->iface);
if (setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, paraThread->iface, strlen(paraThread->iface)) < 0) {
printf("** WARNING ** Cannot bind to device %s (hint: you must be root)\n", paraThread->iface);
fflush(stdout);
}
}
//#endif
paraThread->socketClose = sock;
SrcAddress.ai_family = paraThread->destHost.ai_family;
if (SrcAddress.ai_family == PF_INET) {
SrcAddress.ai_addr = (struct sockaddr *) malloc(sizeof(struct sockaddr_in));
SrcAddress.ai_addrlen = sizeof(struct sockaddr_in);
} else if (SrcAddress.ai_family == PF_INET6) {
SrcAddress.ai_addr = (struct sockaddr *) malloc(sizeof(struct sockaddr_in6));
SrcAddress.ai_addrlen = sizeof(struct sockaddr_in6);
}
pthread_cleanup_push(free, SrcAddress.ai_addr);
int firstpacket = 1;
char HelpSrcAddress[INET6_ADDRSTRLEN];
char HelpDstAddress[INET6_ADDRSTRLEN];
int tmpPort_SrcPort = 0;
int tmpPort_DstPort = 0;
TSTART(_tstart, secs, msecs, first, 0, RECEIVER);
PRINTD(1,"udpSock: main loop\n");
while (1) {
if (passiveMode == false) {
size_r = recvfrom(sock, (char *) payload, MAX_PAYLOAD_SIZE, 0, SrcAddress.ai_addr,
(socklen_t *) &SrcAddress.ai_addrlen);
} else {
size_r = recvfrom(sock, (char *) payload, MAX_PAYLOAD_SIZE, 0, NULL, NULL);
}
PRINTD(2,"udpSock: Received DATAGRAM packet\n");
if (size_r < 0) {
PRINTD(1,"\nudpSock: Error:%s\n",strerror(errno));
#ifndef OSX
reportErrorAndExit("udpSock", "recvfrom", "Cannot receive UDP packets");
#else
sleep(INFINITE);
#endif
}
if (hComm > 0) {
DTR_Disable(hComm);
DTR_Enable(hComm);
}
GET_TIME_OF_DAY(&RcvTime, _tend, _tstart, secs, msecs, 0, RECEIVER);
if ((logCheck != 0) || (logRemote != 0)) {
if (firstpacket == 1) {
if (passiveMode == false) {
getInfo(&SrcAddress, tmpPort_SrcPort, HelpSrcAddress);
getInfo(¶Thread->destHost, tmpPort_DstPort, HelpDstAddress);
} else {
#ifdef WIN32
int len=SrcAddress.ai_addrlen;
getsockname(sock,SrcAddress.ai_addr,&len);
SrcAddress.ai_addrlen=len;
#else
getsockname(sock, SrcAddress.ai_addr, &SrcAddress.ai_addrlen);
#endif
getInfo(¶Thread->destHost, tmpPort_SrcPort, HelpSrcAddress);
getInfo(&SrcAddress, tmpPort_DstPort, HelpDstAddress);
}
firstpacket = 0;
}
#ifdef MULTIPORT
else if (passiveMode == false) {
getInfo(&SrcAddress, tmpPort_SrcPort, HelpSrcAddress);
}
#endif
if (logCheck != 0) {
int net_TimeSec = ntohl(*(uint32_t *) ptrTimeSec);
int net_TimeUsec = ntohl(*(uint32_t *) ptrTimeUsec);
if (paraThread->payloadLogType == PL_STANDARD) {
writeInBufferStandard(&infos[paraThread->count], *(uint32_t *) payload,
*(uint32_t *) ptrSeqNum,
HelpSrcAddress, HelpDstAddress, tmpPort_SrcPort, tmpPort_DstPort,
net_TimeSec,
RcvTime.tv_sec % 86400L, net_TimeUsec, RcvTime.tv_usec, size_r);
} else if (paraThread->payloadLogType == PL_SHORT) {
writeInBufferShort(&infos[paraThread->count], *(uint32_t *) payload,
*(uint32_t *) ptrSeqNum,
HelpSrcAddress, HelpDstAddress, tmpPort_SrcPort, tmpPort_DstPort,
RcvTime.tv_sec % 86400L,
RcvTime.tv_usec, size_r);
} else {
writeInBufferNone(&infos[paraThread->count], paraThread->flowId, HelpSrcAddress,
HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, RcvTime.tv_sec % 86400L,
RcvTime.tv_usec, size_r);
}
}
if (logRemote != 0) {
int net_TimeSec = ntohl(*(uint32_t *) ptrTimeSec);
int net_TimeUsec = ntohl(*(uint32_t *) ptrTimeUsec);
if (paraThread->payloadLogType == PL_STANDARD) {
writeInBufferStandard(&infos[paraThread->count], *(uint32_t *) payload,
*(uint32_t *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, net_TimeSec, RcvTime.tv_sec % 86400L,
net_TimeUsec, RcvTime.tv_usec, size_r);
} else if (paraThread->payloadLogType == PL_SHORT) {
writeInBufferShort(&infos[paraThread->count], *(uint32_t *) payload,
*(uint32_t *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, RcvTime.tv_sec % 86400L,
RcvTime.tv_usec, size_r);
} else {
writeInBufferNone(&infos[paraThread->count], paraThread->flowId, HelpSrcAddress,
HelpDstAddress, tmpPort_SrcPort, tmpPort_DstPort,
RcvTime.tv_sec % 86400L, RcvTime.tv_usec, size_r);
}
infosHostToNet(&infos[paraThread->count]);
}
paraThread->count++;
if (paraThread->count == logbuffer_size) {
if (logCheck != 0)
flushBuffer((ofstream *) paraThread->fileLog, infos, paraThread->count);
else
if (logRemote != 0)
{
MUTEX_THREAD_LOCK(mutexLogRem);
if (sendto(paraThread->logSock, (char *) infos,
paraThread->count * sizeof(struct info), 0,
paraThread->logHost->ai_addr, paraThread->logHost->ai_addrlen) < 0)
reportErrorAndExit("udpSock", "sendto", "Cannot send log infos to LogServer");
paraThread->count = 0;
MUTEX_THREAD_UNLOCK(mutexLogRem);
PRINTD(1,"udpSock: Sent Infos to LogServer\n");
}
}
}
if (paraThread->meter == METER_RTTM) {
if (passiveMode == false) {
if (sendto(sock, (char *) payload, size_r, 0, SrcAddress.ai_addr, SrcAddress.ai_addrlen) < 0)
reportErrorAndExit("udpSock", "sendto", "Cannot send back payload for rttm");
} else {
if (sendto(sock, (char *) payload, size_r, 0, NULL, 0) < 0)
reportErrorAndExit("udpSock", "sendto",
"Cannot send back payload for rttm (Passive Mode)");
}
PRINTD(2,"udpSock: Sent RTTM message\n");
}
}
pthread_cleanup_pop(1);
return NULL;
}
void *tcpSock(void *param)
{
PRINTD(1,"tcpSock: tcpSock started\n");
#ifdef WIN32
int first = 1;
#endif
HANDLE hComm = 0;
paramThread *paraThread;
paraThread = (paramThread *) param;
int sock = 0;
unsigned char payload[MAX_PAYLOAD_SIZE];
struct info *infos = (struct info *) calloc(logbuffer_size, sizeof(info));
struct addrinfo SrcAddress;
in_port_t tmpPort = 0;
int newSock = 0;
int size = 0;
unsigned char *ptrSeqNum = payload + sizeof(uint32_t);
unsigned char *ptrTimeSec = ptrSeqNum + sizeof(uint32_t);
unsigned char *ptrTimeUsec = ptrTimeSec + sizeof(uint32_t);
struct timeval RcvTime;
#ifdef WIN32
LARGE_INTEGER _tstart, _tend;
unsigned long secs = 0, msecs = 0;
#endif
paraThread->addressInfos = infos;
paraThread->count = 0;
memset(payload, 0, MAX_PAYLOAD_SIZE);
if (strcmp(paraThread->serial, "noSerial") != 0) {
hComm = serialUp(paraThread->serial);
if (hComm == INVALID_HANDLE_VALUE)
printf("Error opening interface %s \n", paraThread->serial);
}
bool socketAlreadyOpen = false;
#ifdef MULTIPORT
if ((passiveMode == false) && (paraThread->indexPort > 0)) {
MUTEX_THREAD_LOCK(sharedTcpSockets[paraThread->indexPort].mutexSharedSockets);
sock = sharedTcpSockets[paraThread->indexPort].socket;
if (sock > 0) {
socketAlreadyOpen = true;
}
}
#endif
if (socketAlreadyOpen == false) {
sock = socket(paraThread->destHost.ai_family, SOCK_STREAM, 0);
if (paraThread->dsByte
&& (paraThread->destHost.ai_family == AF_INET)
&& setsockopt(sock, SOL_IP, IP_TOS, (char *) ¶Thread->dsByte, sizeof(BYTE)) < 0) {
printf("** WARNING ** Flow %d. Could not set DS byte to: %d\n", paraThread->flowId, paraThread->dsByte);
}
}
if (sock < 0)
reportErrorAndExit("tcpSock", "socket", "Cannot create a STREAM socket on port");
if ((passiveMode == false) && (socketAlreadyOpen == false)) {
if (bind(sock, paraThread->destHost.ai_addr, paraThread->destHost.ai_addrlen) < 0) {
struct pipeMsg msg;
msg.code = MSG_FT_ERR1;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf(" sending msg error");
}
sleep(INFINITE);
}
}
//#if defined UNIX && ! defined BSD
if ((paraThread->iface) && (socketAlreadyOpen == false)) {
printf("Binding to device %s\n", paraThread->iface);
if (setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, paraThread->iface, strlen(paraThread->iface)) < 0) {
printf("** WARNING ** Cannot bind to device %s (hint: you must be root)\n", paraThread->iface);
fflush(stdout);
}
}
//#endif
if ((passiveMode == false) && (socketAlreadyOpen == false)) {
if (listen(sock, SOMAXCONN) < 0)
reportErrorAndExit("tcpSock", "listen", "Cannot listen on a port");
else {
#ifdef WIN32
int len=paraThread->destHost.ai_addrlen;
getsockname(sock,paraThread->destHost.ai_addr,&len);
paraThread->destHost.ai_addrlen=len;
#else
getsockname(sock, paraThread->destHost.ai_addr, &(paraThread->destHost.ai_addrlen));
#endif
GET_PORT((&(paraThread->destHost)), tmpPort);
printf("Listening on TCP port : %d\n", ntohs(tmpPort));
fflush(stdout);
#ifdef MULTIPORT
if (paraThread->indexPort == 0)
{
paraThread->indexPort = ntohs(tmpPort);
MUTEX_THREAD_LOCK(sharedTcpSockets[paraThread->indexPort].mutexSharedSockets);
}
#endif
struct pipeMsg msg;
msg.code = MSG_FT_OK;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf("error into sending msg to signal manager");
}
}
}
#ifdef MULTIPORT
else if ((passiveMode == false) && (socketAlreadyOpen == true))
{
struct pipeMsg msg;
msg.code = MSG_FT_OK;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf("error into sending msg to signal manager");
}
}
#endif
SrcAddress.ai_family = paraThread->destHost.ai_family;
if (SrcAddress.ai_family == PF_INET) {
SrcAddress.ai_addr = (struct sockaddr *) malloc(sizeof(struct sockaddr_in));
SrcAddress.ai_addrlen = sizeof(struct sockaddr_in);
} else if (SrcAddress.ai_family == PF_INET6) {
SrcAddress.ai_addr = (struct sockaddr *) malloc(sizeof(struct sockaddr_in6));
SrcAddress.ai_addrlen = sizeof(struct sockaddr_in6);
}
pthread_cleanup_push(free, SrcAddress.ai_addr);
if (passiveMode == false) {
if ((newSock = accept(sock, SrcAddress.ai_addr, (socklen_t *) &SrcAddress.ai_addrlen)) < 0)
reportErrorAndExit("tcpSock", "accept", "Cannot accept connection");
#ifdef MULTIPORT
if ((passiveMode == false) && (socketAlreadyOpen == false))
{
sharedTcpSockets[paraThread->indexPort].socket = sock;
}
sharedTcpSockets[paraThread->indexPort].inUse++;
MUTEX_THREAD_UNLOCK(sharedTcpSockets[paraThread->indexPort].mutexSharedSockets);
#else
if ( closeSock(sock) == -1)
reportErrorAndExit("tcpSock","closeSock","Cannot close socket sock");
#endif
paraThread->socketClose = newSock;
} else {
struct addrinfo *SrcAddrForConnect = NULL;
//#if (defined WIN32 && defined IPv6RECV) || defined UNIX || defined BSD
if (paraThread->destHost.ai_family == PF_INET6) {
getaddrinfo("::", NULL, &hint, &SrcAddrForConnect);
} else
//#endif
{
getaddrinfo("0.0.0.0", NULL, &hint, &SrcAddrForConnect);
}
SET_PORT((SrcAddrForConnect), htons((paraThread->portForPssv)));
if (bind(sock, SrcAddrForConnect->ai_addr, SrcAddrForConnect->ai_addrlen) < 0) {
struct pipeMsg msg;
msg.code = MSG_FT_ERR1;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf(" sending msg error");
}
sleep(INFINITE);
}
if (connect(sock, paraThread->destHost.ai_addr, paraThread->destHost.ai_addrlen) < 0)
reportErrorAndExit("tcpSock", "connect", "Cannot connect (Passive Mode)");
PRINTD(1,"tcpSock: Connection establishes (Passive Mode)\n");
freeaddrinfo(SrcAddrForConnect);
newSock = sock;
paraThread->socketClose = sock;
#ifdef WIN32
int len=SrcAddress.ai_addrlen;
getsockname(sock,SrcAddress.ai_addr,&len);
SrcAddress.ai_addrlen=len;
#else
getsockname(sock, SrcAddress.ai_addr, &SrcAddress.ai_addrlen);
#endif
}
int firstpacket = 1;
char HelpSrcAddress[INET6_ADDRSTRLEN];
char HelpDstAddress[INET6_ADDRSTRLEN];
int tmpPort_SrcPort = 0;
int tmpPort_DstPort = 0;
TSTART(_tstart, secs, msecs, first, 0, RECEIVER);
PRINTD(1,"tcpSock: main loop\n");
while (1) {
PRINTD(2, "tcpSock: preambleSize = %d \n",paraThread->preambleSize);
size = TCPrecvPacket((unsigned char*) payload, newSock, paraThread->preambleSize, paraThread->payloadLogType);
if (size <= 0) {
PRINTD(1,"tcpSock: TCPrecvPacket() = %d\n",size);
if (size < 0) {
struct pipeMsg msg;
if (passiveMode == false) {
GET_PORT((&(paraThread->destHost)), tmpPort_DstPort);
} else {
GET_PORT((&SrcAddress), tmpPort_DstPort);
}
printf("Error on TCP port : %d\n", ntohs(tmpPort_DstPort));
printf("Finish on TCP port : %d\n\n", ntohs(tmpPort_DstPort));
fflush(stdout);
msg.code = MSG_FT_ERR_SOCK;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf(" sending msg error");
}
}
sleep(INFINITE);
}
if (hComm > 0) {
DTR_Disable(hComm);
DTR_Enable(hComm);
}
GET_TIME_OF_DAY(&RcvTime, _tend, _tstart, secs, msecs, 0, RECEIVER);
if ((logCheck != 0) || (logRemote != 0)) {
if (firstpacket == 1) {
if (passiveMode == false) {
getInfo(&SrcAddress, tmpPort_SrcPort, HelpSrcAddress);
getInfo(¶Thread->destHost, tmpPort_DstPort, HelpDstAddress);
} else {
#ifdef WIN32
int len=SrcAddress.ai_addrlen;
getsockname(sock,SrcAddress.ai_addr,&len);
SrcAddress.ai_addrlen=len;
#else
getsockname(sock, SrcAddress.ai_addr, &SrcAddress.ai_addrlen);
#endif
getInfo(¶Thread->destHost, tmpPort_SrcPort, HelpSrcAddress);
getInfo(&SrcAddress, tmpPort_DstPort, HelpDstAddress);
}
firstpacket = 0;
}
if (paraThread->l7Proto == L7_PROTO_TELNET)
size = size - 20;
if (logCheck != 0) {
int net_TimeSec = ntohl(*(uint32_t *) ptrTimeSec);
int net_TimeUsec = ntohl(*(uint32_t *) ptrTimeUsec);
if (paraThread->payloadLogType == PL_STANDARD) {
writeInBufferStandard(&infos[paraThread->count], *(uint32_t *) payload,
*(unsigned int *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, net_TimeSec, RcvTime.tv_sec % 86400L,
net_TimeUsec, RcvTime.tv_usec, size);
} else if (paraThread->payloadLogType == PL_SHORT) {
writeInBufferShort(&infos[paraThread->count], *(uint32_t *) payload,
*(unsigned int *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, RcvTime.tv_sec % 86400L,
RcvTime.tv_usec, size);
} else {
writeInBufferNone(&infos[paraThread->count], paraThread->flowId, HelpSrcAddress,
HelpDstAddress, tmpPort_SrcPort, tmpPort_DstPort,
RcvTime.tv_sec % 86400L, RcvTime.tv_usec, size);
}
}
if (logRemote != 0) {
int net_TimeSec = ntohl(*(uint32_t *) ptrTimeSec);
int net_TimeUsec = ntohl(*(uint32_t *) ptrTimeUsec);
if (paraThread->payloadLogType == PL_STANDARD) {
writeInBufferStandard(&infos[paraThread->count], *(uint32_t *) payload,
*(uint32_t *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, net_TimeSec, RcvTime.tv_sec % 86400L,
net_TimeUsec, RcvTime.tv_usec, size);
} else if (paraThread->payloadLogType == PL_SHORT) {
writeInBufferShort(&infos[paraThread->count], *(uint32_t *) payload,
*(uint32_t *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, RcvTime.tv_sec % 86400L,
RcvTime.tv_usec, size);
} else {
writeInBufferNone(&infos[paraThread->count], paraThread->flowId, HelpSrcAddress,
HelpDstAddress, tmpPort_SrcPort, tmpPort_DstPort,
RcvTime.tv_sec % 86400L, RcvTime.tv_usec, size);
}
infosHostToNet(&infos[paraThread->count]);
}
if (size != 0) paraThread->count++;
if (paraThread->count == logbuffer_size) {
if (logCheck != 0)
flushBuffer((ofstream *) paraThread->fileLog, infos, paraThread->count);
else
if (logRemote != 0)
{
MUTEX_THREAD_LOCK(mutexLogRem);
if (sendto(paraThread->logSock, (char *) infos,
paraThread->count * sizeof(struct info), 0,
paraThread->logHost->ai_addr, paraThread->logHost->ai_addrlen) < 0)
reportErrorAndExit("tcpSock", "sendto", "Cannot send log infos to LogServer");
paraThread->count = 0;
MUTEX_THREAD_UNLOCK(mutexLogRem);
PRINTD(1,"tcpSock: Sent infos to LogServer\n");
}
}
}
if (paraThread->meter == METER_RTTM) {
if (sendto(newSock, (char *) payload, size, 0, SrcAddress.ai_addr, SrcAddress.ai_addrlen) < 0)
reportErrorAndExit("tcpSock", "sendto", "Cannot send payload back for rttm");
PRINTD(2,"tcpSock: Sent RTTM infos\n");
}
}
pthread_cleanup_pop(1);
return NULL;
}
BinaryWriter::~BinaryWriter()
{
flushBuffer();
}
void *sctpSock(void *param)
{
PRINTD(1,"sctpSock: sctpSock started\n");
#ifdef WIN32
int first = 1;
#endif
HANDLE hComm = 0;
paramThread *paraThread;
paraThread = (paramThread *) param;
int sock = 0;
unsigned char payload[MAX_PAYLOAD_SIZE];
struct info *infos = (struct info *) calloc(logbuffer_size, sizeof(info));
struct addrinfo SrcAddress;
in_port_t tmpPort = 0;
int newSock = 0;
int size = 0;
unsigned char *ptrSeqNum = payload + sizeof(uint32_t);
unsigned char *ptrTimeSec = ptrSeqNum + sizeof(uint32_t);
unsigned char *ptrTimeUsec = ptrTimeSec + sizeof(uint32_t);
struct timeval RcvTime;
#ifdef WIN32
LARGE_INTEGER _tstart, _tend;
unsigned long secs = 0, msecs = 0;
#endif
int sctpId;
bool newSession = true;
PRINTD(1,"sctpSock: Start of Function. logCheck = %d logRemote = %d \n", logCheck, logRemote);
paraThread->addressInfos = infos;
paraThread->count = 0;
memset(payload, 0, MAX_PAYLOAD_SIZE);
if (strcmp(paraThread->serial, "noSerial") != 0) {
hComm = serialUp(paraThread->serial);
if (hComm == INVALID_HANDLE_VALUE)
printf("Error opening interface %s \n", paraThread->serial);
}
unsigned int port = 0;
GET_PORT((&(paraThread->destHost)), port);
MUTEX_THREAD_LOCK(mutexSctp);
for (sctpId = 0; sctpId < sctpSessionCount; sctpId++) {
if (sctpSessions[sctpId].parsedStreams > 0 && sctpSessions[sctpId].port == port) {
newSession = false;
break;
}
}
if (newSession) {
PRINTD(1,"sctpSock: Receiving new SCTP session on port %d...\n", ntohs(port));
sctpId = sctpSessionCount++;
sctpSessions[sctpId].port = port;
sctpSessions[sctpId].busyStreams = 0;
sctpSessions[sctpId].parsedStreams = 1;
sctpSessions[sctpId].sock = -1;
}
else
sctpSessions[sctpId].parsedStreams++;
PRINTD(1,"sctpSock: Receiving new SCTP stream...\n");
if (newSession) {
sock = socket(paraThread->destHost.ai_family, SOCK_STREAM, IPPROTO_SCTP);
if (sock < 0) {
reportErrorAndExit("sctpSock", "socket", "Cannot create a STREAM socket on port");
}
if (bind(sock, paraThread->destHost.ai_addr, paraThread->destHost.ai_addrlen) < 0) {
struct pipeMsg msg;
msg.code = MSG_FT_ERR1;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf(" sending msg error");
}
sleep(INFINITE);
}
if (listen(sock, SOMAXCONN) < 0) {
reportErrorAndExit("tcpSock", "listen", "Cannot listen on a port");
} else {
#ifdef WIN32
int len = paraThread->destHost.ai_addrlen;
getsockname(sock,paraThread->destHost.ai_addr, &len);
paraThread->destHost.ai_addrlen = len;
#else
getsockname(sock, paraThread->destHost.ai_addr, &(paraThread->destHost.ai_addrlen));
#endif
GET_PORT((&(paraThread->destHost)), tmpPort);
fprintf(stderr, "Listening on STCP port : %d\n", ntohs(tmpPort));
fflush(stderr);
struct pipeMsg msg;
msg.code = MSG_FT_OK;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf("error into sending msg to signal manager");
}
}
SrcAddress.ai_family = paraThread->destHost.ai_family;
if (SrcAddress.ai_family == PF_INET) {
SrcAddress.ai_addr = (struct sockaddr *) malloc(sizeof(struct sockaddr_in));
SrcAddress.ai_addrlen = sizeof(struct sockaddr_in);
} else if (SrcAddress.ai_family == PF_INET6) {
SrcAddress.ai_addr = (struct sockaddr *) malloc(sizeof(struct sockaddr_in6));
SrcAddress.ai_addrlen = sizeof(struct sockaddr_in6);
}
if ((newSock = accept(sock, SrcAddress.ai_addr, (socklen_t *) &SrcAddress.ai_addrlen)) < 0)
reportErrorAndExit("sctpSock", "accept", "Cannot accept connection");
if (closeSock(sock) == -1)
reportErrorAndExit("sctpSock", "closeSock", "Cannot close socket sock");
paraThread->socketClose = newSock;
sctpSessions[sctpId].sock = newSock;
} else {
newSock = sctpSessions[sctpId].sock;
}
MUTEX_THREAD_UNLOCK(mutexSctp);
int firstpacket = 1;
char HelpSrcAddress[INET6_ADDRSTRLEN];
char HelpDstAddress[INET6_ADDRSTRLEN];
int tmpPort_SrcPort = 0;
int tmpPort_DstPort = 0;
TSTART(_tstart, secs, msecs, first, 0, RECEIVER);
PRINTD(1,"sctpSock: main loop\n");
while (1) {
size = SCTPrecvPacket((unsigned char*) payload, newSock, sctpId, paraThread->preambleSize, paraThread->payloadLogType);
PRINTD(2,"sctpSock: Received SCTP data. Size of the received data chinck: %d\n",size);
if (hComm > 0) {
DTR_Disable(hComm);
DTR_Enable(hComm);
}
GET_TIME_OF_DAY(&RcvTime, _tend, _tstart, secs, msecs, 0, RECEIVER);
if ((logCheck != 0) || (logRemote != 0)) {
PRINTD(2,"sctpSock: Log received data \n");
if (firstpacket == 1) {
getInfo(&SrcAddress, tmpPort_SrcPort, HelpSrcAddress);
getInfo(¶Thread->destHost, tmpPort_DstPort, HelpDstAddress);
firstpacket = 0;
}
if (logCheck != 0) {
int net_TimeSec = ntohl(*(uint32_t *) ptrTimeSec);
int net_TimeUsec = ntohl(*(uint32_t *) ptrTimeUsec);
if (paraThread->payloadLogType == PL_STANDARD) {
writeInBufferStandard(&infos[paraThread->count], *(uint32_t *) payload,
*(unsigned int *) ptrSeqNum, HelpSrcAddress, HelpDstAddress, tmpPort_SrcPort,
tmpPort_DstPort, net_TimeSec, RcvTime.tv_sec % 86400L, net_TimeUsec,
RcvTime.tv_usec, size);
} else if (paraThread->payloadLogType == PL_SHORT) {
writeInBufferShort(&infos[paraThread->count], *(uint32_t *) payload,
*(unsigned int *) ptrSeqNum, HelpSrcAddress, HelpDstAddress, tmpPort_SrcPort,
tmpPort_DstPort, RcvTime.tv_sec % 86400L, RcvTime.tv_usec, size);
} else {
writeInBufferNone(&infos[paraThread->count], paraThread->flowId, HelpSrcAddress,
HelpDstAddress, tmpPort_SrcPort, tmpPort_DstPort, RcvTime.tv_sec % 86400L,
RcvTime.tv_usec, size);
}
}
if (logRemote != 0) {
int net_TimeSec = ntohl(*(uint32_t *) ptrTimeSec);
int net_TimeUsec = ntohl(*(uint32_t *) ptrTimeUsec);
if (paraThread->payloadLogType == PL_STANDARD) {
writeInBufferStandard(&infos[paraThread->count], *(uint32_t *) payload,
*(uint32_t *) ptrSeqNum, HelpSrcAddress, HelpDstAddress, tmpPort_SrcPort,
tmpPort_DstPort, net_TimeSec, RcvTime.tv_sec % 86400L, net_TimeUsec,
RcvTime.tv_usec, size);
} else if (paraThread->payloadLogType == PL_SHORT) {
writeInBufferShort(&infos[paraThread->count], *(uint32_t *) payload, *(uint32_t *) ptrSeqNum,
HelpSrcAddress, HelpDstAddress, tmpPort_SrcPort, tmpPort_DstPort,
RcvTime.tv_sec % 86400L, RcvTime.tv_usec, size);
} else {
writeInBufferNone(&infos[paraThread->count], paraThread->flowId, HelpSrcAddress,
HelpDstAddress, tmpPort_SrcPort, tmpPort_DstPort, RcvTime.tv_sec % 86400L,
RcvTime.tv_usec, size);
}
infosHostToNet(&infos[paraThread->count]);
}
paraThread->count++;
if (paraThread->count == logbuffer_size) {
if (logCheck != 0)
flushBuffer((ofstream *) paraThread->fileLog, infos, paraThread->count);
else
if (logRemote != 0)
{
MUTEX_THREAD_LOCK(mutexLogRem);
if (sendto(paraThread->logSock, (char *) infos, paraThread->count * sizeof(struct info), 0,
paraThread->logHost->ai_addr, paraThread->logHost->ai_addrlen) < 0)
reportErrorAndExit("sctpSock", "sendto", "Cannot send log infos to LogServer");
paraThread->count = 0;
MUTEX_THREAD_UNLOCK(mutexLogRem);
PRINTD(1,"sctpSock: Sent infos to LogServer\n");
}
}
}
if (paraThread->meter == METER_RTTM) {
if (sendto(newSock, (char *) payload, size, 0, SrcAddress.ai_addr,
SrcAddress.ai_addrlen) < 0)
reportErrorAndExit("sctpSock", "sendto", "Cannot send payload back for rttm");
PRINTD(2,"sctpSock: Sent RTTM infos\n");
}
}
MUTEX_THREAD_LOCK(mutexSctp);
if (--sctpSessionCount == 0)
free(SrcAddress.ai_addr);
MUTEX_THREAD_UNLOCK(mutexSctp);
return NULL;
}
/* check on command and return 1 if command got
* or 0 if didn't */
int checkServerBufferOnInfo()
{
int len = (cli.sbuf)->count;
int slen = 0;
char * buf = flushBuffer(cli.sbuf);
char * c;
char * sek = buf;
uint32_t * pnum;
if (len == 0)
{
debugl(9, "checkServerBufferOnInfo: No string to analyze\n");
free(buf);
return 0;
}
debugl(6, "checkServerBufferOnInfo: Analyzing string with len=%d: ", len);
for (c = buf; (c - buf) < len; c++)
debugl(6, "%hhu ", *c);
debugl(6, "\n");
switch (*sek++)
{
case 1: /* ok */
processResponse(RESP_OK, NULL, 0);
if (len > 1)
addnStr(cli.sbuf, sek, len - 1);
free(buf);
return 1;
case 2: /* error N */
if (len < 2)
{
addnStr(cli.sbuf, buf, len);
free(buf);
return 0;
}
processResponse(RESP_ERROR, sek, 1);
if (len > 2)
addnStr(cli.sbuf, sek+1, len - 2);
free(buf);
return 1;
case 3: /* stat N */
if (len < 5)
{
addnStr(cli.sbuf, buf, len);
free(buf);
return 0;
}
pnum = (uint32_t *)malloc(sizeof(uint32_t));
*pnum = ntohl(*(uint32_t *)sek);
processResponse(RESP_STAT, pnum, 4);
free(pnum);
if (len > 5)
addnStr(cli.sbuf, sek+4, len - 5);
free(buf);
return 1;
case 4: /* games GAMES */
if (len < 5)
{
addnStr(cli.sbuf, buf, len);
free(buf);
return 0;
}
slen = ntohl(*(uint32_t *)sek);
if (len < (5 + slen))
{
addnStr(cli.sbuf, buf, len);
free(buf);
return 0;
}
processResponse(RESP_GAMES, sek+4, slen);
if (len > (5 + slen))
addnStr(cli.sbuf, sek+4+slen, len - 5 - slen);
free(buf);
return 1;
case 5: /* players PLAYERS */
if (len < 5)
{
addnStr(cli.sbuf, buf, len);
free(buf);
return 0;
}
slen = ntohl(*(uint32_t *)sek);
if (len < (5 + slen))
{
addnStr(cli.sbuf, buf, len);
free(buf);
return 0;
}
processResponse(RESP_PLAYERS, sek+4, slen);
if (len > (5 + slen))
addnStr(cli.sbuf, sek+4+slen, len - 5 - slen);
free(buf);
return 1;
case 6: /* player PLAYER */
if (len < 5)
{
addnStr(cli.sbuf, buf, len);
free(buf);
return 0;
}
slen = ntohl(*(uint32_t *)sek);
if (len < (5 + slen))
{
addnStr(cli.sbuf, buf, len);
free(buf);
return 0;
}
processResponse(RESP_PLAYER, sek+4, slen);
if (len > (5 + slen))
addnStr(cli.sbuf, sek+4+slen, len - 5 - slen);
free(buf);
return 1;
case 7: /* info MES */
if (len < 5)
{
addnStr(cli.sbuf, buf, len);
free(buf);
return 0;
}
slen = ntohl(*(uint32_t *)sek);
if (len < (5 + slen))
{
addnStr(cli.sbuf, buf, len);
free(buf);
return 0;
}
processInfo(sek+4, slen);
if (len > (5 + slen))
addnStr(cli.sbuf, sek+4+slen, len - 5 - slen);
free(buf);
return 1;
case 8: /* market Players Turn sellCount:minPrice buyCount:maxPrice */
if (len < 25)
{
addnStr(cli.sbuf, buf, len);
free(buf);
return 0;
}
processResponse(RESP_MARKET, sek, 24);
if (len > 25)
addnStr(cli.sbuf, sek + 24, len - 25);
free(buf);
return 1;
default:
error("Recieved unknown sequence from server, abort!\n");
cli.clientFin = 1;
return 0;
}
}
ServerLogger::~ServerLogger()
{
flushBuffer();
// This does not work with the destroyed() signal as this destructor is called after the main event loop is done.
thread()->quit();
}
virtual int sync () {
if (flushBuffer() == EOF) {
return -1; // ERROR
}
return 0;
}
/** \copydoc Bag::flush */
void flush () {
//printf("--- flush BagCountCompressedFile %d this %p ---\n",_idx,this);
flushBuffer ();
_file->flush();
}
void fflush_uart(void) {
flushBuffer();
}
char BSL430_writeMemory(unsigned long startAddr, unsigned int size, char* data)
{
unsigned long i;
char exceptions = SUCCESSFUL_OPERATION;
// Note: this function compiles quite differently based on whether the
// BSL is based out of RAM, or not. RAM based BSLs can use buffering
// and perform a block long word write. This is primarily used for
// USB BSLs for performance increase.
// Flash based BSLs will use the second second of code, below
#ifdef RAM_BASED_BSL
if (LockedStatus == UNLOCKED)
{
if ((BlockBufferStart == 0) || BlockBufferNext == startAddr)
{
// if we are starting, or continuing a block...
if (BlockBufferStart == 0)
{
BlockBufferStart = startAddr; // if starting a new block, reset
// start addr
}
BlockBufferNext = startAddr + size; // always update the next addr for
// streaming
for (i = 0; i < size;)
{
BlockBuffer[BlockBufferPtr++] = *data; // add the incoming data to the buffer
data++;
startAddr++;
i++; // i incrimented here for check below
if (((startAddr) & 0x7F) == 0x00) // we've crossed a 128 byte block
// boundary
{
flushBuffer(); // flush out old buffer, writing...
// begin write on block boundary
return BSL430_writeMemory(startAddr, (size - i), data);
} // if
} // for
} // if buffer start
else
{
// for when data exists in the buffer, but we are jumping to a new place to write...
flushBuffer(); // flush out old buffer, writing..
return BSL430_writeMemory(startAddr, size, data); // begin buffering new data
}
} // if unlocked
else
{
exceptions = BSL_LOCKED;
}
// Below is the writeMemory function compiled with Flash based BSLs.
#else
for (i = startAddr; i < startAddr + size; i++)
{
# ifndef RAM_WRITE_ONLY_BSL
// if the start address is odd, or we're 1 byte from end...
if ((startAddr & 0x01) || i == startAddr + size - 1)
# endif
{
exceptions = BSL430_writeByte(i, *data);
data += 1;
}
# ifndef RAM_WRITE_ONLY_BSL
// else, we're on an even addr, and have at least 1 word left..
else
{
exceptions = BSL430_writeWord(i, *(int *)data);
data += 2;
i++;
}
if (exceptions != SUCCESSFUL_OPERATION)
{
return exceptions;
} // if
# endif
} // for
#endif
return exceptions;
}
QgsVectorLayerExporter::~QgsVectorLayerExporter()
{
flushBuffer();
delete mProvider;
}
bool WriteThread::internalOpen()
{
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"["+QString::number(id)+"] internalOpen destination: "+name);
if(stopIt)
return false;
if(file.isOpen())
{
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"["+QString::number(id)+"] already open! destination: "+file.fileName());
return false;
}
//set to LISTBLOCKSIZE
while(freeBlock.available()<ULTRACOPIER_PLUGIN_MAXBUFFERBLOCK)
freeBlock.release();
if(freeBlock.available()>ULTRACOPIER_PLUGIN_MAXBUFFERBLOCK)
freeBlock.acquire(freeBlock.available()-ULTRACOPIER_PLUGIN_MAXBUFFERBLOCK);
stopIt=false;
CurentCopiedSize=0;
endDetected=false;
#ifdef ULTRACOPIER_PLUGIN_DEBUG
stat=InodeOperation;
#endif
file.setFileName(name);
//mkpath check if exists and return true if already exists
QFileInfo destinationInfo(file);
QDir destinationFolder;
{
mkpathTransfer->acquire();
if(!destinationFolder.exists(destinationInfo.absolutePath()))
{
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"["+QString::number(id)+"] "+QString("Try create the path: %1")
.arg(destinationInfo.absolutePath()));
if(!destinationFolder.mkpath(destinationInfo.absolutePath()))
{
if(!destinationFolder.exists(destinationInfo.absolutePath()))
{
/// \todo do real folder error here
errorString_internal="mkpath error on destination";
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"["+QString::number(id)+"] "+QString("Unable create the folder: %1, error: %2")
.arg(destinationInfo.absolutePath())
.arg(errorString_internal));
emit error();
#ifdef ULTRACOPIER_PLUGIN_DEBUG
stat=Idle;
#endif
return false;
}
}
}
mkpathTransfer->release();
}
if(stopIt)
return false;
//try open it
QIODevice::OpenMode flags=QIODevice::ReadWrite;
if(!buffer)
flags|=QIODevice::Unbuffered;
if(file.open(flags))
{
flushBuffer();
if(stopIt)
return false;
file.seek(0);
if(stopIt)
return false;
file.resize(startSize);
if(stopIt)
return false;
emit opened();
#ifdef ULTRACOPIER_PLUGIN_DEBUG
stat=Idle;
#endif
isOpen.acquire();
needRemoveTheFile=false;
return true;
}
else
{
if(stopIt)
return false;
errorString_internal=file.errorString();
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"["+QString::number(id)+"] "+QString("Unable to open: %1, error: %2").arg(name).arg(errorString_internal));
emit error();
#ifdef ULTRACOPIER_PLUGIN_DEBUG
stat=Idle;
#endif
return false;
}
}
void EGS_ParticleTrackContainer::startNewTrack(EGS_ParticleTrack::ParticleInfo *p) {
if (m_nTracks >= m_bufferSize) flushBuffer();
m_nTracks++;
m_isScoring[m_nTracks-1] = true;
m_buffer[m_nTracks-1]->setParticleInfo(p);
}
void
write(unsigned int theChar)
{
if (theChar <= 0x7F)
{
write(char(theChar));
}
else if (theChar <= 0x7FF)
{
if (m_bufferRemaining < 2)
{
flushBuffer();
}
*m_bufferPosition = leadingByteOf2(bits7to11(theChar));
++m_bufferPosition;
*m_bufferPosition = trailingByte(bits1to6(theChar));
++m_bufferPosition;
m_bufferRemaining -= 2;
}
else if (theChar <= 0xFFFF)
{
// We should never get a high or low surrogate here...
assert(theChar < 0xD800 || theChar > 0xDBFF);
assert(theChar < 0xDC00 || theChar > 0xDFFF);
if (m_bufferRemaining < 3)
{
flushBuffer();
}
*m_bufferPosition = leadingByteOf3(bits13to16(theChar));
++m_bufferPosition;
*m_bufferPosition = trailingByte(bits7to12(theChar));
++m_bufferPosition;
*m_bufferPosition = trailingByte(bits1to6(theChar));
++m_bufferPosition;
m_bufferRemaining -= 3;
}
else if (theChar <= 0x10FFFF)
{
if (m_bufferRemaining < 4)
{
flushBuffer();
}
*m_bufferPosition = leadingByteOf4(bits19to21(theChar));
++m_bufferPosition;
*m_bufferPosition = trailingByte(bits13to18(theChar));
++m_bufferPosition;
*m_bufferPosition = trailingByte(bits7to12(theChar));
++m_bufferPosition;
*m_bufferPosition = trailingByte(bits1to6(theChar));
++m_bufferPosition;
m_bufferRemaining -= 4;
}
else
{
XalanFormatterWriter::throwInvalidCharacterException(theChar, getMemoryManager());
}
}
static void flushAll(int terminate){
for( int i = 0; i < MAX_FILTERS; i++){
flushBuffer(i, terminate);
}
}
/* returns
* 0 if not enough commands remain or
* 1 if commands remain in buffer */
int checkClientBufOnCommand()
{
int len = (cli.cbuf)->count;
char * buf = flushBuffer(cli.cbuf);
char * c;
Task * t;
int stParse;
if (len == 0)
{
debugl(9, "checkClientBufOnCommand: No string to analyze\n");
free(buf);
return 0;
}
debugl(6, "checkClientBufOnCommand: Analyzing string with len=%d: ", len);
for (c = buf; (c - buf) < len; c++)
debugl(6, "%hhu ", *c);
debugl(6, "\n");
debugl(9, "checkClientBufOnCommand: Attempting to get string: ");
c = buf;
while (*c != '\012' && (c - buf) < len)
{
debugl(9, "%c(%hhu) ", *c, *c);
c++;
}
debugl(9, "end:%c(%hhu) ss=%d\n", *c, *c, c - buf);
if (*c != '\012' || (c - buf) == len)
{
addnStr(cli.cbuf, buf, len);
free(buf);
return 0;
}
else if ((c - buf + 1) < len)
{
addnStr(cli.cbuf, c + 1, len - (c - buf + 1));
}
debugl(9, "checkClientBufOnCommand: String got successfully!\n");
delTask(&t);
initParserByString(buf);
stParse = parse(&t);
clearParser();
if (stParse == PS_OK)
{
defineTaskType(t);
if (t->type != TASK_UNKNOWN)
{
if (t->type & TASKT_SERVER)
{
t->type &= ~TASKT_SERVER;
sendCommand(t);
}
else if (t->type &TASKT_CLIENT)
{
t->type &= ~TASKT_CLIENT;
execCommand(t);
}
}
else
error("Unknown command!\n");
}
else if (stParse == PS_ERROR)
echoParserError();
if ((c - buf + 1) == len)
return 0;
else
return 1;
}
void Lexer::pushToken(TokenType type) {
file->tokenStream->push_back(new Token(this->file, flushBuffer(), type));
}
PackageModel::PackageModel(QObject *parent) :
QAbstractListModel(parent)
{
#ifdef PACKAGEMODEL_LOG
qDebug() << Q_FUNC_INFO;
#endif
m_addTimer.setInterval(200);
m_addTimer.setSingleShot(true);
connect(&m_addTimer, SIGNAL(timeout()), this, SLOT(flushBuffer()));
QHash<int, QByteArray> roles;
roles[DisplayNameRole] = "packageDisplayName";
roles[IsMarkedRole] = "packageIsMarked";
roles[PackageObjectRole] = "packageObject";
roles[IdRole] = "packageId";
roles[NameRole] = "packageName";
roles[VersionRole] = "packageVersion";
roles[ArchRole] = "packageArch";
roles[DataRole] = "packageData";
roles[SummaryRole] = "packageSummary";
roles[InfoRole] = "packageInfo";
roles[IconRole] = "packageIcon";
roles[IsUpdateAvailableRole] = "packageIsUpdateAvailable";
roles[UpdateIdRole] = "packageUpdateId";
roles[UpdateNameRole] = "packageUpdateName";
roles[UpdateVersionRole] = "packageUpdateVersion";
roles[UpdateArchRole] = "packageUpdateArch";
roles[UpdateDataRole] = "packageUpdateData";
roles[UpdateSummaryRole] = "packageUpdateSummary";
roles[UpdateInfoRole] = "packageUpdateInfo";
roles[UpdateIconRole] = "packageUpdateIcon";
roles[DetailsAvailableRole] = "packageDetailsAvailable";
roles[DependsAvailableRole] = "packageDependsAvailable";
roles[UpdateDetailsAvailableRole] = "packageUpdateDetailsAvailable";
roles[UpdateInfoAvailableRole] = "packageUpdateInfoAvailable";
roles[DetailsLicenseRole] = "packageDetailsLicense";
roles[DetailsGroupRole] = "packageDetailsGroup";
roles[DetailsDescriptionRole] = "packageDetailsDescription";
roles[DetailsUrlRole] = "packageDetailsUrl";
roles[DetailsSizeRole] = "packageDetailsSize";
roles[UpdateDetailsLicenseRole] = "packageUpdateDetailsLicense";
roles[UpdateDetailsGroupRole] = "packageUpdateDetailsGroup";
roles[UpdateDetailsDescriptionRole] = "packageUpdateDetailsDescription";
roles[UpdateDetailsUrlRole] = "packageUpdateDetailsUrl";
roles[UpdateDetailsSizeRole] = "packageUpdateDetailsSize";
roles[UpdateUpdatesRole] = "packageUpdateUpdates";
roles[UpdateObsoletesRole] = "packageUpdateObsoletes";
roles[UpdateVendorUrlRole] = "packageUpdateVendorUrl";
roles[UpdateBugzillaUrlRole] = "packageUpdateBugzillaUrl";
roles[UpdateCveUrlRole] = "packageUpdateCveUrl";
roles[UpdateRestartNeededRole] = "packageUpdateRestart";
roles[UpdateTextRole] = "packageUpdateText";
roles[UpdateChangeLogRole] = "packageUpdateChangeLog";
roles[UpdateStateRole] = "packageUpdateState";
roles[UpdateIssuedRole] = "packageUpdateIssued";
roles[UpdateUpdatedRole] = "packageUpdateUpdated";
setRoleNames(roles);
connect(&m_packageMarkings, SIGNAL(changed()), this, SIGNAL(markedCountChanged()));
}
thread_buffer::~thread_buffer() {
flushBuffer();
flushStrings();
}
void XSerializeEngine::flush()
{
if (isStoring())
flushBuffer();
}
/**
@brief Controls the meat of the processing.
Basically a state machine, which accumulates the incoming
stream of characters and chops them up into meaningful
chunks, then passes those chunks off to other routines
to further process and output.
@param[in] inFile the file to process
@param[out] outFile where to write the result
@return int
@retval 0 everything went smoothly
@retval -108 unable to allocate memory
*/
int processFile(FILE *outFile, FILE *inFile)
{
tBuffer *buf;
int prevc, c, nextc; /* needs to be int to hold EOF */
int depthCurly,depthRound;
bool inComment, inCppComment;
bool inPreprocessor;
bool inSingleQuotes, inDoubleQuotes;
bool inBetween, isLiteral, isChar1;
bool atStart, doFlush;
buf = (tBuffer *)malloc(sizeof(tBuffer));
if (buf == NULL)
{
fprintf(stderr,
"### error: unable to allocate a buffer\n");
return (-108);
}
initBuffer(buf,outFile);
depthCurly = 0;
depthRound = 0;
isLiteral = false;
inComment = false;
inCppComment = false;
inPreprocessor = false;
inSingleQuotes = false;
inDoubleQuotes = false;
atStart = true;
inBetween = true;
isChar1 = true;
doFlush = false;
prevc = '\0';
c = fgetc(inFile);
while (c != EOF)
{
nextc = fgetc(inFile);
/*
the main state machine
*/
if (isLiteral)
{
/* normally the 'literal' is a single character.
but in the odd case of DOS cr/lf pairs, they
should be treated as one logical character */
if ((c != '\r' || nextc != '\n')
&& (c != '\n' || nextc != '\r'))
{
isLiteral = false;
}
}
else if (inComment)
{
if (inCppComment)
{
if (c == '\n' || c == '\r')
{
inCppComment = false;
inComment = false;
inPreprocessor = false;
isChar1 = true;
if (depthCurly == 0)
{
buf->description.end = buf->ptr;
++buf->description.count;
if (buf->fileComment)
{
flushBuffer(buf);
buf->fileComment = false;
}
}
else
{
parseComment(buf);
}
}
}
else
{
if (prevc == '*' && c == '/')
{
inComment = false;
if (depthCurly == 0)
{
buf->description.end = buf->ptr + 1;
++buf->description.count;
if (buf->fileComment)
{
doFlush = true;
}
}
else
{
parseComment(buf);
}
}
}
}
else if (inPreprocessor)
{
switch (c)
{
case '\n':
case '\r':
if (inCppComment)
{
inCppComment = false;
inComment = false;
if (depthCurly == 0)
{
buf->description.end = buf->ptr;
++buf->description.count;
}
else
{
parseComment(buf);
}
}
if (depthCurly == 0 && !inComment)
{
doFlush = true;
}
inPreprocessor = false;
isChar1 = true;
break;
case '/':
switch (nextc)
{
case '/':
inCppComment = true;
/* fall through */
case '*':
inComment = true;
break;
}
if (inComment)
{
if (depthCurly == 0)
{
flushBuffer(buf);
buf->description.start = buf->ptr;
}
else
{
buf->commentStart = buf->ptr;
}
}
break;
}
}
else if (inSingleQuotes)
{
switch (c)
{
case '\'':
inSingleQuotes = false;
break;
case '\\':
isLiteral = true;
break;
}
}
else if (inDoubleQuotes)
{
switch (c)
{
case '"':
inDoubleQuotes = false;
break;
case '\\':
isLiteral = true;
break;
}
}
else {
switch (c)
{
case '\\':
isLiteral = true;
break;
case '/':
switch (nextc)
{
case '*':
inComment = true;
break;
case '/':
inCppComment = true;
inComment = true;
break;
}
if (inComment)
{
if (depthCurly == 0)
{
flushBuffer(buf);
buf->description.start = buf->ptr;
}
else
{
buf->commentStart = buf->ptr;
}
}
break;
case '#':
/* is this the first non-whitepace char on the line? */
if (isChar1)
{
if (depthCurly == 0)
{
/* if there was a comment preceeding this pre-
processor directive, it wasn't a description */
buf->description.count = 0;
buf->description.start = NULL;
buf->description.end = NULL;
}
inPreprocessor = true;
}
break;
case '\'':
inSingleQuotes = true;
break;
case '"':
inDoubleQuotes = true;
break;
case '(':
if (depthCurly == 0 && depthRound == 0)
{
buf->function.end = buf->ptr;
++buf->function.count;
buf->arglist.start = buf->ptr;
}
++depthRound;
break;
case ')':
--depthRound;
if (depthCurly == 0 && depthRound == 0)
{
buf->arglist.end = buf->ptr + 1;
++buf->arglist.count;
}
break;
case '{':
if (depthCurly == 0)
{
buf->body.start = buf->ptr;
}
else
parseStatement(buf);
++depthCurly;
inBetween = true;
break;
case '}':
--depthCurly;
if (depthCurly == 0)
{
buf->body.end = buf->ptr + 1;
++buf->body.count;
doFlush = true;
}
else
parseStatement(buf);
inBetween = true;
break;
case ';':
if (depthCurly == 0)
doFlush = true;
else
parseStatement(buf);
inBetween = true;
break;
case '\n':
case '\r':
isChar1 = true;
break;
default:
if (inBetween && !isspace(c))
{
if (depthCurly == 0)
buf->function.start = buf->ptr;
else
buf->statementStart = buf->ptr;
inBetween = false;
}
break;
}
}
/* check the first non-whitespace characters to see if
it's the start of a comment. If so, assume it's the
file's header comment and flag to handle it specially */
if (atStart && !isspace(c))
{
atStart = false;
if (inComment)
{
/* set flag to act at the end of the comment */
buf->fileComment = true;
}
else
{
/* it's not a comment, so insert a new file comment */
newFileComment(buf);
}
}
if (emitChar(buf, c) != 0)
{
/* buffer overflowed! hopefully this won't
happen very often... no choice but to flush */
doFlush = true;
}
if (doFlush)
{
doFlush = false;
flushBuffer(buf);
buf->fileComment = false;
}
/* if the currect character isn't whitespace, we're
not at the first character of the line any more. */
if (isChar1 && !isspace(c))
isChar1 = false;
prevc = c;
c = nextc;
} /* end while */
/* flush whatever may be left in the buffer */
flushBuffer(buf);
free(buf);
return 0;
}
int Exiv2::http(dict_t& request,dict_t& response,std::string& errors)
{
if ( !request.count("verb") ) request["verb" ] = "GET";
if ( !request.count("header") ) request["header" ] = "" ;
if ( !request.count("version")) request["version"] = "1.0";
if ( !request.count("port") ) request["port" ] = "" ;
std::string file;
errors = "";
int result = 0;
////////////////////////////////////
// Windows specific code
#ifdef WIN32
WSADATA wsaData;
WSAStartup(MAKEWORD(2,2), &wsaData);
#endif
const char* servername = request["server" ].c_str();
const char* page = request["page" ].c_str();
const char* verb = request["verb" ].c_str();
const char* header = request["header" ].c_str();
const char* version = request["version"].c_str();
const char* port = request["port" ].c_str();
const char* servername_p = servername;
const char* port_p = port ;
std::string url = std::string("http://") + request["server"] + request["page"];
// parse and change server if using a proxy
const char* PROXI = "HTTP_PROXY";
const char* proxi = "http_proxy";
const char* PROXY = getenv(PROXI);
const char* proxy = getenv(proxi);
bool bProx = PROXY || proxy;
const char* prox = bProx ? (proxy?proxy:PROXY):"";
Exiv2::Uri Proxy = Exiv2::Uri::Parse(prox);
// find the dictionary of no_proxy servers
const char* NO_PROXI = "NO_PROXY";
const char* no_proxi = "no_proxy";
const char* NO_PROXY = getenv(NO_PROXI);
const char* no_proxy = getenv(no_proxi);
bool bNoProxy = NO_PROXY||no_proxy;
std::string no_prox = std::string(bNoProxy?(no_proxy?no_proxy:NO_PROXY):"");
Exiv2::dict_t noProxy= stringToDict(no_prox + ",localhost,127.0.0.1");
// if the server is on the no_proxy list ... ignore the proxy!
if ( noProxy.count(servername) ) bProx = false;
if ( bProx ) {
servername_p = Proxy.Host.c_str();
port_p = Proxy.Port.c_str();
page = url.c_str();
std::string p(proxy?proxi:PROXI);
// std::cerr << p << '=' << prox << " page = " << page << std::endl;
}
if ( !port [0] ) port = "80";
if ( !port_p[0] ) port_p = "80";
////////////////////////////////////
// open the socket
int sockfd = (int) socket(AF_INET , SOCK_STREAM,IPPROTO_TCP) ;
if ( sockfd < 0 ) return error("unable to create socket\n",NULL,NULL,0) ;
// connect the socket to the server
int server = -1 ;
// fill in the address
struct sockaddr_in serv_addr ;
int serv_len = sizeof(serv_addr);
memset((char *)&serv_addr,0,serv_len);
serv_addr.sin_addr.s_addr = inet_addr(servername_p);
serv_addr.sin_family = AF_INET ;
serv_addr.sin_port = htons(atoi(port_p));
// convert unknown servername into IP address
// http://publib.boulder.ibm.com/infocenter/iseries/v5r3/index.jsp?topic=/rzab6/rzab6uafinet.htm
if (serv_addr.sin_addr.s_addr == (unsigned long)INADDR_NONE)
{
struct hostent* host = gethostbyname(servername_p);
if ( !host ) return error("no such host",servername_p,NULL,0);
memcpy(&serv_addr.sin_addr,host->h_addr,sizeof(serv_addr.sin_addr));
}
makeNonBlocking(sockfd) ;
////////////////////////////////////
// and connect
server = connect(sockfd, (const struct sockaddr *) &serv_addr, serv_len) ;
if ( server == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK )
return error(errors,"error - unable to connect to server = %s port = %s wsa_error = %d",servername_p,port_p,WSAGetLastError());
char buffer[32*1024+1];
size_t buff_l= sizeof buffer - 1 ;
////////////////////////////////////
// format the request
#ifdef MSDEV_2003
int n = sprintf(buffer,httpTemplate,verb,page,version,servername,header) ;
#else
int n = snprintf(buffer,buff_l,httpTemplate,verb,page,version,servername,header) ;
#endif
buffer[n] = 0 ;
response["requestheaders"]=std::string(buffer,n);
////////////////////////////////////
// send the header (we'll have to wait for the connection by the non-blocking socket)
while ( sleep_ >= 0 && send(sockfd,buffer,n,0) == SOCKET_ERROR /* && WSAGetLastError() == WSAENOTCONN */ ) {
Sleep(snooze) ;
sleep_ -= snooze ;
}
if ( sleep_ < 0 )
return error(errors,"error - timeout connecting to server = %s port = %s wsa_error = %d",servername,port,WSAGetLastError());
int end = 0 ; // write position in buffer
bool bSearching = true ; // looking for headers in the response
int status= 200 ; // assume happiness
////////////////////////////////////
// read and process the response
int err ;
n=forgive(recv(sockfd,buffer,(int)buff_l,0),err) ;
while ( n >= 0 && OK(status) ) {
if ( n ) {
end += n ;
buffer[end] = 0 ;
size_t body = 0 ; // start of body
if ( bSearching ) {
// search for the body
for ( size_t b = 0 ; bSearching && b < lengthof(blankLines) ; b++ ) {
if ( strstr(buffer,blankLines[b]) ) {
bSearching = false ;
body = (int) ( strstr(buffer,blankLines[b]) - buffer ) + strlen(blankLines[b]) ;
status = atoi(strchr(buffer,' ')) ;
}
}
// parse response headers
char* h = buffer;
char C = ':' ;
char N = '\n';
int i = 0 ; // initial byte in buffer
while(buffer[i] == N ) i++;
h = strchr(h+i,N)+1;
response[""]=std::string(buffer+i).substr(0,h-buffer-2);
result = atoi(strchr(buffer,' '));
char* c = strchr(h,C);
char* n = strchr(h,N);
while ( c && n && c < n && h < buffer+body ) {
std::string key(h);
std::string value(c+1);
key = key.substr(0,c-h);
value = value.substr(0,n-c-1);
response[key]=value;
h = n+1;
c = strchr(h,C);
n = strchr(h,N);
}
}
// if the bufffer's full and we're still searching - give up!
// this handles the possibility that there are no headers
if ( bSearching && buff_l-end < 10 ) {
bSearching = false ;
body = 0 ;
}
if ( !bSearching && OK(status) ) {
flushBuffer(buffer,body,end,file);
}
}
n=forgive(recv(sockfd,buffer+end,(int)(buff_l-end),0),err) ;
if ( !n ) {
Sleep(snooze) ;
sleep_ -= snooze ;
if ( sleep_ < 0 ) n = FINISH ;
}
}
if ( n != FINISH || !OK(status) ) {
#ifdef MSDEV_2003
sprintf(buffer,"wsa_error = %d,n = %d,sleep_ = %d status = %d"
, WSAGetLastError()
, n
, sleep_
, status
) ;
#else
snprintf(buffer,sizeof buffer,"wsa_error = %d,n = %d,sleep_ = %d status = %d"
, WSAGetLastError()
, n
, sleep_
, status
) ;
#endif
error(errors,buffer,NULL,NULL,0) ;
} else if ( bSearching && OK(status) ) {
if ( end ) {
// we finished OK without finding headers, flush the buffer
flushBuffer(buffer,0,end,file) ;
} else {
return error(errors,"error - no response from server = %s port = %s wsa_error = %d",servername,port,WSAGetLastError());
}
}
////////////////////////////////////
// close sockets
closesocket(server) ;
closesocket(sockfd) ;
response["body"]=file;
return result;
}
FileOutputStream::~FileOutputStream()
{
flushBuffer();
flushInternal();
closeHandle();
}
void *dccpSock(void *param)
{
PRINTD(1,"dccpSock: dccpSock started\n");
HANDLE hComm = 0;
int sock = 0;
int sendCheck = 0;
unsigned char payload[MAX_PAYLOAD_SIZE];
struct info *infos = (struct info *) calloc(logbuffer_size, sizeof(info));
struct addrinfo SrcAddress;
in_port_t tmpPort = 0;
int newSock = 0;
int size = 0;
int optval = 0;
struct timeval RcvTime;
unsigned char *ptrSeqNum = payload + sizeof(uint32_t);
unsigned char *ptrTimeSec = ptrSeqNum + sizeof(uint32_t);
unsigned char *ptrTimeUsec = ptrTimeSec + sizeof(uint32_t);
paramThread *paraThread;
paraThread = (paramThread *) param;
paraThread->addressInfos = infos;
paraThread->count = 0;
if (strcmp(paraThread->serial, "noSerial") != 0) {
hComm = serialUp(paraThread->serial);
if (hComm == INVALID_HANDLE_VALUE)
printf("Error opening interface %s \n", paraThread->serial);
}
sock = socket(paraThread->destHost.ai_family, SOCK_DCCP, 0);
if (sock < 0)
reportErrorAndExit("dccpSock", "socket", "Cannot create a DCCP socket on port");
if (paraThread->dsByte
&& (paraThread->destHost.ai_family == AF_INET)
&& setsockopt(sock, SOL_IP, IP_TOS, (char *) ¶Thread->dsByte, sizeof(BYTE)) < 0) {
printf("** WARNING ** Flow %d. Could not set DS byte to: %d\n", paraThread->flowId, paraThread->dsByte);
}
if (bind(sock, paraThread->destHost.ai_addr, paraThread->destHost.ai_addrlen) < 0) {
printf(" Error into bind function\n");
struct pipeMsg msg;
msg.code = MSG_FT_ERR1;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0)
printf(" sending msg error");
sleep(INFINITE);
}
if (setsockopt(sock, SOL_DCCP, DCCP_SOCKOPT_SERVICE, &optval, sizeof(optval)) < 0)
reportErrorAndExit("dccpSock", "setsockopt", "Cannot set option DCCP_SERVICE");
if (listen(sock, SOMAXCONN) < 0)
reportErrorAndExit("dccpSock", "listen", "Cannot listen on a port");
else {
#ifdef WIN32
int len=paraThread->destHost.ai_addrlen;
getsockname(sock,paraThread->destHost.ai_addr,&len);
paraThread->destHost.ai_addrlen=len;
#else
getsockname(sock, paraThread->destHost.ai_addr, &(paraThread->destHost.ai_addrlen));
#endif
GET_PORT((&(paraThread->destHost)), tmpPort);
fprintf(stderr, "Listening on DCCP port : %d\n", ntohs(tmpPort));
fflush(stderr);
struct pipeMsg msg;
msg.code = MSG_FT_OK;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf("error into sending msg to signal manager");
}
}
SrcAddress.ai_family = paraThread->destHost.ai_family;
if (SrcAddress.ai_family == PF_INET) {
SrcAddress.ai_addr = (struct sockaddr *) malloc(sizeof(struct sockaddr_in));
SrcAddress.ai_addrlen = sizeof(struct sockaddr_in);
} else if (SrcAddress.ai_family == PF_INET6) {
SrcAddress.ai_addr = (struct sockaddr *) malloc(sizeof(struct sockaddr_in6));
SrcAddress.ai_addrlen = sizeof(struct sockaddr_in6);
}
pthread_cleanup_push(free, SrcAddress.ai_addr);
if ((newSock = accept(sock, SrcAddress.ai_addr, (socklen_t *) &SrcAddress.ai_addrlen)) < 0)
reportErrorAndExit("dccpSock", "accept", "Cannot accept connection");
if (closeSock(sock) == -1)
reportErrorAndExit("dccpSock", "closeSock", "Cannot close socket sock");
paraThread->socketClose = newSock;
int firstpacket = 1;
char HelpSrcAddress[INET6_ADDRSTRLEN];
char HelpDstAddress[INET6_ADDRSTRLEN];
int tmpPort_SrcPort = 0;
int tmpPort_DstPort = 0;
TSTART(_tstart, secs, msecs, first, 0, RECEIVER);
PRINTD(1,"dccpSock: main loop\n");
while (1) {
size = recv(newSock, (char *) payload, MAX_PAYLOAD_SIZE, 0);
if (size < 0)
reportErrorAndExit("udpSock", "recvfrom", "Cannot receive UDP packets");
else if (size > 0) {
PRINTD(2,"dccpSock: Received DCCP packet, size %d\n", size);
if (hComm > 0) {
DTR_Disable(hComm);
DTR_Enable(hComm);
}
GET_TIME_OF_DAY(&RcvTime, _tend, _tstart, secs, msecs, 0, RECEIVER);
if ((logCheck != 0) || (logRemote != 0)) {
if (firstpacket == 1) {
getInfo(&SrcAddress, tmpPort_SrcPort, HelpSrcAddress);
getInfo(¶Thread->destHost, tmpPort_DstPort, HelpDstAddress);
firstpacket = 0;
}
if (logCheck != 0) {
int net_TimeSec = ntohl(*(uint32_t *) ptrTimeSec);
int net_TimeUsec = ntohl(*(uint32_t *) ptrTimeUsec);
if (paraThread->payloadLogType == PL_STANDARD) {
writeInBufferStandard(&infos[paraThread->count], *(uint32_t *) payload,
*(unsigned int *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, net_TimeSec,
RcvTime.tv_sec % 86400L, net_TimeUsec, RcvTime.tv_usec, size);
} else if (paraThread->payloadLogType == PL_SHORT) {
writeInBufferShort(&infos[paraThread->count], *(uint32_t *) payload,
*(unsigned int *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, RcvTime.tv_sec % 86400L,
RcvTime.tv_usec, size);
} else {
writeInBufferNone(&infos[paraThread->count], paraThread->flowId,
HelpSrcAddress, HelpDstAddress, tmpPort_SrcPort,
tmpPort_DstPort, RcvTime.tv_sec % 86400L, RcvTime.tv_usec,
size);
}
}
if (logRemote != 0) {
int net_TimeSec = ntohl(*(uint32_t *) ptrTimeSec);
int net_TimeUsec = ntohl(*(uint32_t *) ptrTimeUsec);
if (paraThread->payloadLogType == PL_STANDARD) {
writeInBufferStandard(&infos[paraThread->count], *(uint32_t *) payload,
*(uint32_t *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, net_TimeSec,
RcvTime.tv_sec % 86400L, net_TimeUsec, RcvTime.tv_usec, size);
} else if (paraThread->payloadLogType == PL_SHORT) {
writeInBufferShort(&infos[paraThread->count], *(uint32_t *) payload,
*(uint32_t *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, RcvTime.tv_sec % 86400L,
RcvTime.tv_usec, size);
} else {
writeInBufferNone(&infos[paraThread->count], paraThread->flowId,
HelpSrcAddress, HelpDstAddress, tmpPort_SrcPort,
tmpPort_DstPort, RcvTime.tv_sec % 86400L, RcvTime.tv_usec,
size);
}
infosHostToNet(&infos[paraThread->count]);
}
paraThread->count++;
if (paraThread->count == logbuffer_size) {
if (logCheck != 0)
flushBuffer((ofstream *) paraThread->fileLog, infos, paraThread->count);
else
if (logRemote != 0) {
MUTEX_THREAD_LOCK(mutexLogRem);
if (sendto(paraThread->logSock, (char *) infos,
paraThread->count * sizeof(struct info), 0,
paraThread->logHost->ai_addr, paraThread->logHost->ai_addrlen)
< 0)
reportErrorAndExit("dccpSock", "sendto",
"Cannot send log infos to LogServer");
paraThread->count = 0;
MUTEX_THREAD_UNLOCK(mutexLogRem);
PRINTD(1,"dccpSock: Sent infos to LogServer\n");
}
}
}
if (paraThread->meter == METER_RTTM) {
do {
PRINTD(2,"dccpSock: Trying to send RTTM infos\n");
sendCheck = sendto(newSock, (char *) payload, size, 0, SrcAddress.ai_addr,
SrcAddress.ai_addrlen);
} while (sendCheck < 0 && errno == EAGAIN);
if (sendCheck < 0)
reportErrorAndExit("dccpSock", "sendto", "Cannot send payload back for rttm");
PRINTD(2,"dccpSock: Sent RTTM infos\n");
}
}
}
pthread_cleanup_pop(1);
return NULL;
}
void FileOutputStream::flush()
{
flushBuffer();
flushInternal();
}
void *icmpSock(void *param)
{
PRINTD(1,"icmpSock: icmpSock started\n");
#ifdef WIN32
int first = 1;
#endif
int dimheader = 0;
HANDLE hComm = 0;
paramThread *paraThread;
paraThread = (paramThread *) param;
int sock = 0;
unsigned char buffer[MAX_PAYLOAD_SIZE + 32];
unsigned char payload[MAX_PAYLOAD_SIZE];
struct info *infos = (struct info *) calloc(logbuffer_size, sizeof(info));
struct addrinfo SrcAddress;
int size_r = 0;
struct timeval RcvTime;
#ifdef WIN32
struct addrinfo* sockAddress;
LARGE_INTEGER _tstart, _tend;
unsigned long secs = 0, msecs = 0;
#endif
char *ptrSeqNum = (char *) payload + sizeof(uint32_t);
char *ptrTimeSec = ptrSeqNum + sizeof(uint32_t);
char *ptrTimeUsec = ptrTimeSec + sizeof(uint32_t);
paraThread->addressInfos = infos;
paraThread->count = 0;
if (strcmp(paraThread->serial, "noSerial") != 0) {
hComm = serialUp(paraThread->serial);
if (hComm == INVALID_HANDLE_VALUE)
printf("Error opening interface %s \n", paraThread->serial);
}
sock = socket(paraThread->destHost.ai_family, SOCK_RAW,
(paraThread->destHost.ai_family == AF_INET) ? IPPROTO_ICMP : IPPROTO_ICMPV6);
if (sock < 0) {
struct pipeMsg msg;
printf("icmpSock - error into create socket");
msg.code = MSG_FT_ERR2;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf(" sending msg error");
}
sleep(INFINITE);
}
if (paraThread->dsByte
&& (paraThread->destHost.ai_family == AF_INET)
&& setsockopt(sock, SOL_IP, IP_TOS, (char *) ¶Thread->dsByte, sizeof(BYTE)) < 0) {
printf("** WARNING ** Flow %d. Could not set DS byte to: %d\n", paraThread->flowId, paraThread->dsByte);
}
#ifdef WIN32
#ifdef IPv6RECV
if ( getaddrinfo("::", NULL, &hint, &sockAddress) != 0)
reportErrorAndExit("icmpSock","getaddrinfo IPv6","Cannot set the default IP log address");
#else
if ( getaddrinfo("0.0.0.0", NULL, &hint, &sockAddress) != 0)
reportErrorAndExit("icmpSock","getaddrinfo IPv4","Cannot set the default IP log address");
#endif
if ( bind(sock, sockAddress->ai_addr, sockAddress->ai_addrlen))
reportErrorAndExit("icmpSock","bind","Cannot bind a socket on port");
#endif
//#if defined UNIX && ! defined BSD
if (paraThread->iface) {
printf("Binding to device %s\n", paraThread->iface);
if (setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, paraThread->iface, strlen(paraThread->iface)) < 0) {
printf("** WARNING ** Cannot bind to device %s (hint: you must be root)\n", paraThread->iface);
fflush(stdout);
}
}
//#endif
struct pipeMsg msg;
msg.code = MSG_FT_OK;
msg.flowId = paraThread->flowId;
if (sendPipeMsg(paraThread->rPipe, &msg) < 0) {
printf("error into sending msg to signal manager");
}
fprintf(stderr, "Listening to ICMP traffic\n");
paraThread->socketClose = sock;
SrcAddress.ai_family = paraThread->destHost.ai_family;
if (SrcAddress.ai_family == PF_INET) {
SrcAddress.ai_addr = (struct sockaddr *) malloc(sizeof(struct sockaddr_in));
SrcAddress.ai_addrlen = sizeof(struct sockaddr_in);
dimheader = sizeof(icmp) + sizeof(iphdr);
} else if (SrcAddress.ai_family == PF_INET6) {
SrcAddress.ai_addr = (struct sockaddr *) malloc(sizeof(struct sockaddr_in6));
SrcAddress.ai_addrlen = sizeof(struct sockaddr_in6);
dimheader = sizeof(icmpv6);
}
pthread_cleanup_push(free, SrcAddress.ai_addr);
int firstpacket = 1;
char HelpSrcAddress[INET6_ADDRSTRLEN];
char HelpDstAddress[INET6_ADDRSTRLEN];
int tmpPort_SrcPort = 0;
int tmpPort_DstPort = 0;
TSTART(_tstart, secs, msecs, first, 0, RECEIVER);
PRINTD(1,"icmpSock: main loop\n");
while (1) {
size_r = recvfrom(sock, (char *) buffer, MAX_PAYLOAD_SIZE + dimheader, 0,
SrcAddress.ai_addr, (socklen_t *) &SrcAddress.ai_addrlen);
PRINTD(2,"icmpSock: Received RAW Packet :%d\n", size_r);
if (size_r < 0)
reportErrorAndExit("icmpSock", "recvfrom", "Cannot receive RAW packets");
char *ptr = (char *) buffer;
ptr = ptr + dimheader;
size_r = size_r - dimheader;
memcpy(&payload, ptr, size_r);
if (hComm > 0) {
DTR_Disable(hComm);
DTR_Enable(hComm);
}
GET_TIME_OF_DAY(&RcvTime, _tend, _tstart, secs, msecs, 0, RECEIVER);
if ((logCheck != 0) || (logRemote != 0)) {
if (firstpacket == 1) {
getInfo(&SrcAddress, tmpPort_SrcPort, HelpSrcAddress);
getInfo(¶Thread->destHost, tmpPort_DstPort, HelpDstAddress);
firstpacket = 0;
}
if (logCheck != 0) {
int net_TimeSec = ntohl(*(uint32_t *) ptrTimeSec);
int net_TimeUsec = ntohl(*(uint32_t *) ptrTimeUsec);
if (paraThread->payloadLogType == PL_STANDARD) {
writeInBufferStandard(&infos[paraThread->count], *(uint32_t *) payload,
*(uint32_t *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, net_TimeSec, RcvTime.tv_sec % 86400L,
net_TimeUsec, RcvTime.tv_usec, size_r);
} else if (paraThread->payloadLogType == PL_SHORT) {
writeInBufferShort(&infos[paraThread->count], *(uint32_t *) payload,
*(uint32_t *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, RcvTime.tv_sec % 86400L,
RcvTime.tv_usec, size_r);
} else {
writeInBufferNone(&infos[paraThread->count], paraThread->flowId, HelpSrcAddress,
HelpDstAddress, tmpPort_SrcPort, tmpPort_DstPort,
RcvTime.tv_sec % 86400L, RcvTime.tv_usec, size_r);
}
}
if (logRemote != 0) {
int net_TimeSec = ntohl(*(uint32_t *) ptrTimeSec);
int net_TimeUsec = ntohl(*(uint32_t *) ptrTimeUsec);
if (paraThread->payloadLogType == PL_STANDARD) {
writeInBufferStandard(&infos[paraThread->count], *(uint32_t *) payload,
*(uint32_t *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, net_TimeSec, RcvTime.tv_sec % 86400L,
net_TimeUsec, RcvTime.tv_usec, size_r);
} else if (paraThread->payloadLogType == PL_SHORT) {
writeInBufferShort(&infos[paraThread->count], *(uint32_t *) payload,
*(uint32_t *) ptrSeqNum, HelpSrcAddress, HelpDstAddress,
tmpPort_SrcPort, tmpPort_DstPort, RcvTime.tv_sec % 86400L,
RcvTime.tv_usec, size_r);
} else {
writeInBufferNone(&infos[paraThread->count], paraThread->flowId, HelpSrcAddress,
HelpDstAddress, tmpPort_SrcPort, tmpPort_DstPort,
RcvTime.tv_sec % 86400L, RcvTime.tv_usec, size_r);
}
infosHostToNet(&infos[paraThread->count]);
}
paraThread->count++;
if (paraThread->count == logbuffer_size) {
if (logCheck != 0)
flushBuffer((ofstream *) paraThread->fileLog, infos, paraThread->count);
else
if (logRemote != 0)
{
MUTEX_THREAD_LOCK(mutexLogRem);
if (sendto(paraThread->logSock, (char *) infos,
paraThread->count * sizeof(struct info), 0,
paraThread->logHost->ai_addr, paraThread->logHost->ai_addrlen) < 0)
reportErrorAndExit("icmpSock", "sendto", "Cannot send log infos to LogServer");
paraThread->count = 0;
MUTEX_THREAD_UNLOCK(mutexLogRem);
PRINTD(1,"icmpSock: Sent Infos to LogServer\n");
}
}
}
}
pthread_cleanup_pop(1);
return NULL;
}
void BufferedWriter::flushBuffer()
{
flushBuffer(mBuffer);
}
void LocalFileFormatTarget::flush()
{
flushBuffer();
}
void handleServerEvent(Message * mes)
{
Player * sp = NULL;
Game * sg = NULL;
char * nick = NULL;
Message nmes;
if (mes->sndr_t == O_PLAYER)
{
sp = mes->sndr.player;
nick = getNickname(sp);
}
if (mes->sndr_t == O_GAME)
sg = mes->sndr.game;
switch(mes->type)
{
case MEST_PLAYER_JOIN_SERVER:
info("%s has joined on the server\n", nick);
info("Players on server/in hall: %d/%d\n", srv.nPlayers, srv.hallPlayers);
{
Buffer * msg = newBuffer();
Buffer * info = newBuffer();
mPlayer * mp;
mGame * mg;
char * str;
uint32_t i;
/* generating MES part */
addnStr(msg, infos[INFO_PLAYER_JOINS_SERVER], 1);
i = htonl(sp->pid);
addnStr(msg, &i, sizeof(i));
/* generating INFO part */
addnStr(info, answrs[ANSWR_INFO], 1);
i = htonl(msg->count);
addnStr(info, &i, sizeof(i));
i = msg->count;
str = flushBuffer(msg);
addnStr(info, str, i);
free(str);
/* sending info message */
i = info->count;
str = flushBuffer(info);
/* players in hall */
for (mp = srv.players; mp != NULL; mp = mp->next)
if (mp->player != sp)
write(mp->player->fd, str, i);
/* players in games */
for (mg = srv.games; mg != NULL; mg = mg->next)
for (mp = mg->game->players; mp != NULL; mp = mp->next)
if (mp->player != sp)
write(mp->player->fd, str, i);
free(str);
clearBuffer(msg);
free(msg);
clearBuffer(info);
free(info);
}
break;
case MEST_PLAYER_LEAVE_SERVER:
info("%s has leaved the server\n", nick);
{
Buffer * msg = newBuffer();
Buffer * info = newBuffer();
mPlayer * mp;
mGame * mg;
char * str;
uint32_t i;
/* generating MES part */
addnStr(msg, infos[INFO_PLAYER_LEAVES_SERVER], 1);
i = htonl(sp->pid);
addnStr(msg, &i, sizeof(i));
/* generating INFO part */
addnStr(info, answrs[ANSWR_INFO], 1);
i = htonl(msg->count);
addnStr(info, &i, sizeof(i));
i = msg->count;
str = flushBuffer(msg);
addnStr(info, str, i);
free(str);
/* sending info message */
i = info->count;
str = flushBuffer(info);
/* players in hall */
for (mp = srv.players; mp != NULL; mp = mp->next)
if (mp->player != sp)
write(mp->player->fd, str, i);
/* players in games */
for (mg = srv.games; mg != NULL; mg = mg->next)
for (mp = mg->game->players; mp != NULL; mp = mp->next)
if (mp->player != sp)
write(mp->player->fd, str, i);
free(str);
clearBuffer(msg);
free(msg);
clearBuffer(info);
free(info);
}
freePlayer(sp, sp->game);
info("Players on server/in hall: %d/%d\n", srv.nPlayers, srv.hallPlayers);
break;
case MEST_PLAYER_CHANGES_NICK:
{
Buffer * msg = newBuffer();
Buffer * info = newBuffer();
mPlayer * mp;
mGame * mg;
char * str;
uint32_t i;
/* generating MES part */
addnStr(msg, infos[INFO_PLAYER_CHANGES_NICK], 1);
i = htonl(sp->pid);
addnStr(msg, &i, sizeof(i));
i = htonl(strlen(nick));
addnStr(msg, &i, sizeof(i));
i = strlen(nick);
addnStr(msg, nick, i);
/* generating INFO part */
addnStr(info, answrs[ANSWR_INFO], 1);
i = htonl(msg->count);
addnStr(info, &i, sizeof(i));
i = msg->count;
str = flushBuffer(msg);
addnStr(info, str, i);
free(str);
/* sending info message */
i = info->count;
str = flushBuffer(info);
/* players in hall */
for (mp = srv.players; mp != NULL; mp = mp->next)
if (mp->player != sp)
write(mp->player->fd, str, i);
/* players in games */
for (mg = srv.games; mg != NULL; mg = mg->next)
for (mp = mg->game->players; mp != NULL; mp = mp->next)
if (mp->player != sp)
write(mp->player->fd, str, i);
free(str);
clearBuffer(msg);
free(msg);
clearBuffer(info);
free(info);
}
break;
case MEST_COMMAND_UNKNOWN:
info("%s send unknown command and will be disconnected\n", nick);
{
char err = 255;
write(sp->fd, answrs[ANSWR_ERROR], 1);
write(sp->fd, &err, 1);
}
nmes.sndr_t = O_SERVER;
nmes.rcvr_t = O_GAME;
nmes.rcvr.game = sp->game;
if (sp->game != NULL)
nmes.type = MEST_PLAYER_LEAVE_GAME;
else
nmes.type = MEST_PLAYER_LEAVES_HALL;
nmes.len = 0;
nmes.data = NULL;
sendMessage(&nmes);
nmes.sndr_t = O_SERVER;
nmes.rcvr_t = O_PLAYER;
nmes.rcvr.player = sp;
nmes.type = MEST_PLAYER_KICKED_FROM_SERVER;
nmes.len = 0;
nmes.data = NULL;
sendMessage(&nmes);
break;
case MEST_COMMAND_NICK:
info("%s sets nick into %s\n", nick, mes->data);
if (sp->nick != NULL)
free(sp->nick);
sp->nick = mes->data;
write(sp->fd, answrs[ANSWR_OK], 1);
nmes.sndr_t = O_PLAYER;
nmes.sndr.player = sp;
nmes.rcvr_t = O_SERVER;
nmes.type = MEST_PLAYER_CHANGES_NICK;
nmes.len = 0;
nmes.data = NULL;
sendMessage(&nmes);
break;
case MEST_COMMAND_ADM:
info("%s trying to get Adm privilegies\n", nick);
if (strcmp(cfg.passkey, mes->data) == 0)
sp->adm = 1;
if (sp->adm == 1)
{
info("%s grants its Adm privilegies\n", nick);
write(sp->fd, answrs[ANSWR_OK], 1);
}
else
{
char err = 0;
info("Attempt was failed\n");
write(sp->fd, answrs[ANSWR_ERROR], 1);
write(sp->fd, &err, 1);
}
free(mes->data);
break;
case MEST_COMMAND_JOIN:
info("%s trying to join into game #%d\n", nick, *(uint32_t *)(mes->data));
if (sp->game == NULL)
{
Game * g = findGameByGid(*(uint32_t *)(mes->data));
if (g == NULL)
{
info("Not found game #%d\n", *(uint32_t *)(mes->data));
char err = 1;
write(sp->fd, answrs[ANSWR_ERROR], 1);
write(sp->fd, &err, 1);
}
else
{
info("%s joins into game #%d\n", nick, *(uint32_t *)(mes->data));
IntoGame(g, sp);
write(sp->fd, answrs[ANSWR_OK], 1);
nmes.sndr_t = O_PLAYER;
nmes.sndr.player = sp;
nmes.rcvr_t = O_GAME;
nmes.rcvr.game = g;
nmes.type = MEST_PLAYER_JOIN_GAME;
nmes.len = 0;
nmes.data = NULL;
sendMessage(&nmes);
nmes.sndr_t = O_PLAYER;
nmes.sndr.player = sp;
nmes.rcvr_t = O_GAME;
nmes.rcvr.game = NULL;
nmes.type = MEST_PLAYER_LEAVES_HALL;
nmes.len = sizeof(g);
nmes.data = g;
sendMessage(&nmes);
nmes.sndr_t = O_PLAYER;
nmes.sndr.player = sp;
nmes.rcvr_t = O_GAME;
nmes.rcvr.game = g;
nmes.type = MEST_PLAYERS_STAT_GAME;
nmes.len = 0;
nmes.data = NULL;
sendMessage(&nmes);
}
}
else
{
info("%s already in game #%d\n", sp->game->gid);
char err = 0;
write(sp->fd, answrs[ANSWR_ERROR], 1);
write(sp->fd, &err, 1);
}
free(mes->data);
break;
case MEST_COMMAND_GAMES:
info("%s trying to get games list\n", nick);
{
uint32_t i;
mGame * mg = srv.games;
Buffer * buf = newBuffer();
char * str;
i = htonl(srv.nGames);
addnStr(buf, &i, sizeof(i));
while (mg != NULL)
{
i = htonl(mg->game->gid);
addnStr(buf, &i, sizeof(i));
i = htonl(mg->game->nPlayers);
addnStr(buf, &i, sizeof(i));
mg = mg->next;
}
write(sp->fd, answrs[ANSWR_GAMES], 1);
i = htonl(buf->count);
write(sp->fd, &i, sizeof(i));
i = buf->count;
str = flushBuffer(buf);
write(sp->fd, str, i);
free(str);
clearBuffer(buf);
free(buf);
}
break;
case MEST_COMMAND_PLAYERS:
info("%s trying to get players list in game #%d\n", nick, *(uint32_t *)(mes->data));
{
int gid = *(uint32_t *)(mes->data);
Game * g = NULL;
if (gid != 0)
{
g = findGameByGid(gid);
if (g == NULL)
{
char err = 0;
info("Not found game #%d\n", *(uint32_t *)(mes->data));
write(sp->fd, answrs[ANSWR_ERROR], 1);
write(sp->fd, &err, 1);
}
}
if (gid == 0 || g != NULL)
{
uint32_t i;
char * n;
mPlayer * mp;
Buffer * buf = newBuffer();
char * str;
if (gid == 0)
mp = srv.players;
else
mp = g->players;
i = htonl(gid);
addnStr(buf, &i, sizeof(i));
if (gid == 0)
i = htonl(srv.hallPlayers);
else
i = htonl(g->nPlayers);
addnStr(buf, &i, sizeof(i));
while (mp != NULL)
{
i = htonl(mp->player->pid);
addnStr(buf, &i, sizeof(i));
n = getNickname(mp->player);
i = htonl(strlen(n));
addnStr(buf, &i, sizeof(i));
addnStr(buf, n, strlen(n));
mp = mp->next;
}
write(sp->fd, answrs[ANSWR_PLAYERS], 1);
i = htonl(buf->count);
write(sp->fd, &i, sizeof(i));
i = buf->count;
str = flushBuffer(buf);
write(sp->fd, str, i);
free(str);
clearBuffer(buf);
free(buf);
}
}
break;
case MEST_COMMAND_CREATEGAME:
info("%s trying to create game\n", nick);
if (!sp->adm)
{
char err = 0;
info("%s not granted to create games\n", nick);
write(sp->fd, answrs[ANSWR_ERROR], 1);
write(sp->fd, &err, 1);
}
else
{
Game * g = newGame();
uint32_t i;
g->gid = srv.nextGid++;
addGame(g);
i = htonl(g->gid);
info("%s created game #%d\n", nick, g->gid);
write(sp->fd, answrs[ANSWR_STAT], 1);
write(sp->fd, &i, sizeof(i));
nmes.sndr_t = O_PLAYER;
nmes.sndr.player = sp;
nmes.rcvr_t = O_GAME;
nmes.rcvr.game = NULL;
nmes.type = MEST_NEW_GAME;
nmes.len = sizeof(g);
nmes.data = g;
sendMessage(&nmes);
}
break;
case MEST_COMMAND_DELETEGAME:
info("%s trying to delete game #%d\n", nick, *(uint32_t *)(mes->data));
if (!sp->adm)
{
char err = 0;
info("%s not granted to delete games\n", nick);
write(sp->fd, answrs[ANSWR_ERROR], 1);
write(sp->fd, &err, 1);
}
else
{
Game * g = findGameByGid(*(uint32_t *)(mes->data));
if (g == NULL)
{
char err = 1;
info("Not found game #%d\n", *(uint32_t *)(mes->data));
write(sp->fd, answrs[ANSWR_ERROR], 1);
write(sp->fd, &err, 1);
}
else
{
mPlayer * mp;
info("%s deleted game #%d\n", nick, g->gid);
write(sp->fd, answrs[ANSWR_OK], 1);
for (mp = g->players; mp != NULL; mp = mp->next)
{
nmes.sndr_t = O_PLAYER;
nmes.sndr.player = sp;
nmes.rcvr_t = O_PLAYER;
nmes.rcvr.player = mp->player;
nmes.type = MEST_PLAYER_KICKED_FROM_GAME;
nmes.len = sizeof(g);
nmes.data = g;
sendMessage(&nmes);
}
nmes.sndr_t = O_PLAYER;
nmes.sndr.player = sp;
nmes.rcvr_t = O_GAME;
nmes.rcvr.game = g;
nmes.type = MEST_GAME_OVER;
nmes.len = 0;
nmes.data = NULL;
sendMessage(&nmes);
}
}
break;
case MEST_COMMAND_PLAYER:
info("%s trying to get info about player #%d\n", nick, *(uint32_t *)(mes->data));
{
Player * np = findPlayerByPid(*(uint32_t *)(mes->data));
if (np == NULL)
{
char err = 0;
info("Not found player #%d\n", *(uint32_t *)(mes->data));
write(sp->fd, answrs[ANSWR_ERROR], 1);
write(sp->fd, &err, 1);
}
else
{
uint32_t i;
Buffer * buf = newBuffer();
char * str;
/* #pid */
i = htonl(np->pid);
addnStr(buf, &i, sizeof(i));
/* #game */
if (np->game == NULL)
i = 0;
else
i = np->game->gid;
i = htonl(i);
addnStr(buf, &i, sizeof(i));
/* game characteristics */
if (np->game->started)
{
i = htonl(1);
addnStr(buf, &i, sizeof(i));
i = htonl(np->mat);
addnStr(buf, &i, sizeof(i));
i = htonl(np->prod);
addnStr(buf, &i, sizeof(i));
i = htonl(np->bf);
addnStr(buf, &i, sizeof(i));
i = htonl(countFactories(np));
addnStr(buf, &i, sizeof(i));
i = htonl(np->money);
addnStr(buf, &i, sizeof(i));
}
else
{
i = htonl(0);
addnStr(buf, &i, sizeof(i));
addnStr(buf, &i, sizeof(i));
addnStr(buf, &i, sizeof(i));
addnStr(buf, &i, sizeof(i));
addnStr(buf, &i, sizeof(i));
addnStr(buf, &i, sizeof(i));
}
/* len NICK */
str = getNickname(np);
i = htonl(strlen(str));
addnStr(buf, &i, sizeof(i));
addnStr(buf, str, strlen(str));
/* player len MES */
write(sp->fd, answrs[ANSWR_PLAYER], 1);
i = htonl(buf->count);
write(sp->fd, &i, sizeof(i));
i = buf->count;
str = flushBuffer(buf);
write(sp->fd, str, i);
free(str);
clearBuffer(buf);
free(buf);
}
}
break;
}
}
