std::vector<MaterialBuffer> ModelBinaryLoader::readMaterialBuffer(int p_NumberOfMaterialBuffers, std::istream* p_Input)
{
MaterialBuffer temp;
std::vector<MaterialBuffer> tempBuffer;
for(int i = 0; i < p_NumberOfMaterialBuffers; i++)
{
byteToString(p_Input, temp.material);
byteToInt(p_Input, temp.start);
byteToInt(p_Input, temp.length);
tempBuffer.push_back(temp);
}
return tempBuffer;
}
int aDecode(string hiByte, string loByte){
// Hex strings converted back to integers should be in the range [0x00..0x7F]
int lowByteEncoded = byteToInt(loByte);
int hiByteEncoded = byteToInt(hiByte);
cout << "lowByteEncoded = " << lowByteEncoded << endl;
cout << "hiByteEncoded = " << hiByteEncoded << endl;
if (lowByteEncoded < LOWER_RANGE_HEX || lowByteEncoded > UPPER_RANGE_HEX ||
hiByteEncoded < LOWER_RANGE_HEX || hiByteEncoded > UPPER_RANGE_HEX){
throw std::out_of_range("Out of range");
}
return -1;
}
void ModelBinaryLoader::byteToString(std::istream* p_Input, std::string& p_Return)
{
int strLength = 0;
byteToInt(p_Input, strLength);
std::vector<char> buffer(strLength);
p_Input->read( buffer.data(), strLength);
p_Return = std::string(buffer.data(), strLength);
}
ModelBinaryLoader::Header ModelBinaryLoader::readHeader(std::istream* p_Input)
{
Header tempHeader;
tempHeader.m_Animated = true;
tempHeader.m_Transparent = true;
tempHeader.m_CollideAble = true;
int tempBool;
byteToString(p_Input, tempHeader.m_ModelName);
byteToInt(p_Input, tempHeader.m_NumMaterial);
byteToInt(p_Input, tempHeader.m_NumVertex);
byteToInt(p_Input, tempHeader.m_NumMaterialBuffer);
byteToInt(p_Input, tempBool);
if(tempBool == 0)
{
tempHeader.m_Animated= false;
}
byteToInt(p_Input, tempBool);
if(tempBool == 0)
{
tempHeader.m_Transparent = false;
}
byteToInt(p_Input, tempBool);
if(tempBool == 0)
{
tempHeader.m_CollideAble = false;
}
return tempHeader;
}
int
recvFrom
(Peer *peer, byte *headerBuf, byte *dataBuf)
{
int headerSize = readHeader(peer, headerBuf, HEADERSIZE);
if(headerSize == 0 )
{
printf("Non Header \n");
return 0;
}
int length = byteToInt(headerBuf, 8);
int dataSize = readData(peer , dataBuf, length );
printf("[ from %s ] type : %d, redesc : %d length : %d data : %s \n",
peer->ip, byteToInt(headerBuf,0),
byteToInt(headerBuf, 4),
byteToInt(headerBuf, 8),
dataBuf);
return (headerSize + dataSize);
}
int main(int argc, char *argv[]) {
if(argc != 3)
{
exitWithError("Usage: tstream2jpeg data_file_path outputPath");
}
char* tStreamPath = argv[1]; // Set the file in path
char jpegPath[255]; // Buffer for current working dir
int i = 0, len, ctr = 0;
char* workingDir = argv[2];
//getcwd(workingDir, 255); // Get current working directory
FILE* tstream = fopen(tStreamPath, "rb"); // Open the telemetry stream
fseek(tstream, 0, SEEK_END); // Seek to EOF
len = ftell(tstream); // Find file size
fseek(tstream, 0, SEEK_SET); // Seek to beginning of file
byte* buf = (byte*)malloc(len); // Allocate file in memory
fread(buf, 1, len-1, tstream); // Read file into memory
sprintf(jpegPath, "%s/image%d.jpeg", workingDir, i++);
FILE* jpeg = fopen(jpegPath, "wb");
while(ctr < len) // While not at end of buffer
{
ctr++; // Ignore first 0xAA
ctr += 2; // Ignore bytes received
byte conBytes[2]; // Buffer for bytes contained
conBytes[1] = *(buf+(ctr++)); // Fill buffer
conBytes[0] = *(buf+(ctr++)); // Fill buffer
uint16_t con = byteToInt(conBytes); // Get int of bytes contained
printf("Creating image of size %d bytes\n", con);
if(*(buf+ctr) == 0xFF && *(buf+ctr+1) == 0xD8)
{
fclose(jpeg);
sprintf(jpegPath, "%s/image%d.jpeg", workingDir, i++);
jpeg = fopen(jpegPath, "wb");
} // Open JPEG for writing
fwrite(buf+ctr, 1, con, jpeg); // Write to the JPEG
ctr += con; // Move ptr past image data
ctr++; // Ignore checksum
}
free(buf);
fclose(tstream);
return EXIT_SUCCESS;
}
void client_recv(int event_fd, Peer *peer)
{
unsigned char headerBuf[HEADERSIZE*5];
unsigned char dataBuf[DATASIZE*5];
unsigned char sendBuf[DATASIZE*5];
char *tokenBuf[DATASIZE];
int len;
memset(headerBuf, 0x00, HEADERSIZE*5);
memset(dataBuf, 0x00, DATASIZE*5);
memset(tokenBuf, 0x00, DATASIZE);
Peer t_peer;
t_peer.socket = event_fd;
len = recvFrom(&t_peer, headerBuf, dataBuf);
int type = byteToInt(headerBuf, 0);
if(len > 0 )
{
/* 조회 */
// who(id), when(time), where(ip), what(packet), how(to Inner Server, to Outer Client), why(type:purpose)
log_line_init();
log_user_name (event_fd, peer);
//log_user_ip (event_fd, peer);
//log_user_ptype(type);
log_line_feed();
/* Nonce, Timestapm 저장 */
/*
addNonce(con, tokenBuf[index-1]);
addNonce(con, tokenBuf[index]);
*/
/*
int i;0
for(i=0; i<index-1; i++)
{
strcat(sendBuf, tokenBuf[i]);
strcat(sendBuf, tokenBuf
}
*/
}
if( len < 0 || len == 0 )
{
userpool_delete(event_fd, peer);
close(event_fd);
return;
}
switch(type)
{
case ERROR_REPORT :
{
// Auth, dir, HDFS Error Reporting Packet Protocol
Peer client;
client.socket = byteToInt(headerBuf, 4);
/* 로그를 기록하는 부분 XML형태로 */
sendTo(&client, 0, g_epoll_auth ,strlen((char *)dataBuf), dataBuf);
break;
}
case LOGIN_REQUEST :
{
if(g_epoll_auth == 0)
{
printf("auth server not running \n");
break;
}
Peer auth;
auth.socket = g_epoll_auth;
len = sendTo(&auth, 1, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case LOGIN_RESPONSE :
{
char id_buf[20];
Peer client;
memset(id_buf, 0x00, 20);
client.socket = byteToInt(headerBuf, 4);
/* Align User to Admin Table */
get_id_from_data(dataBuf, id_buf, strlen(dataBuf));
userpool_add_name(client.socket, peer ,id_buf);
printf("id : %s\n", id_buf);
sendTo(&client, 2, g_epoll_auth ,strlen((char *) dataBuf), dataBuf);
//userpool_add(client.socket, client.ip,
break;
}
case LOGOUT_REQUEST :
{
Peer client;
client.socket = event_fd;
sendTo(&client, 4, event_fd, strlen((char *) dataBuf), dataBuf);
userpool_delete(client.socket, peer);
//close(client.socket);
printf("delete\n");
break;
}
case LOGOUT_RESPONSE :
{
/* This is not Server Responsibility */
}
case SIGNUP_REQUEST :
{
Peer auth;
auth.socket = g_epoll_auth;
if(g_epoll_auth == 0)
{
//Exception
printf("auth server not running \n");
break;
}
sendTo(&auth, 5, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case SIGNUP_RESPONSE :
{
Peer client;
client.socket = byteToInt(headerBuf, 4);
sendTo(&client, 6, g_epoll_dir ,strlen((char *) dataBuf), dataBuf);
break;
}
case DIR_LIST_REQUEST :
{
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
sendTo(&dirServ, 7, event_fd, strlen((char *) dataBuf), dataBuf);
}
case DIR_LIST_RESPONSE :
{
Peer client;
client.socket = byteToInt(headerBuf, 4);
sendTo(&client, 8, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case DIR_CREAT_REQUEST:
{
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
sendTo(&dirServ, 9, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case DIR_KEY_RESPONSE:
{
Peer peer;
peer.socket = byteToInt(headerBuf, 4);
sendTo(&peer, 10, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case ACCESS_DIR_REQUEST:
{
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
sendTo(&dirServ, 11, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case ACCESS_DIR_RESPONSE:
{
Peer peer;
peer.socket = byteToInt(headerBuf, 4);
sendTo(&peer, 12, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case FOLDER_CREAT_REQUEST:
{
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
sendTo(&dirServ, 13, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case FOLDER_CREAT_RESPONSE:
{
Peer peer;
peer.socket = byteToInt(headerBuf, 4);
sendTo(&peer, 14, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case META_UPLOAD_REQUEST:
{
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
/* event fd 클라이언트 소켓 디스크립터 번호 */
sendTo(&dirServ, 15, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case META_UPLOAD_RESPONSE:
{
Peer peer;
peer.socket = byteToInt(headerBuf, 4);
sendTo(&peer, 16, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case META_DOWNLOAD_REQUEST:
{
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
/* event fd 클라이언트 소켓 디스크립터 번호 */
sendTo(&dirServ, 17, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case META_DOWNLOAD_RESPONSE:
{
Peer peer;
peer.socket = byteToInt(headerBuf, 4);
sendTo(&peer, 18, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case SHARE_REQUEST:
{
/* Client to Dir */
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
/* event fd 클라이언트 소켓 디스크립터 번호 */
sendTo(&dirServ, 21, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case 22:
{
/* Dir to Client */
Peer peer;
peer.socket = byteToInt(headerBuf, 4);
sendTo(&peer, 22, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case SHARE_LIST_REQUEST:
{
/* Client to Dir */
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
/* event fd 클라이언트 소켓 디스크립터 번호 */
sendTo(&dirServ, 23, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case SHARE_LIST_RESPONSE:
{
/* Dir to Client */
Peer peer;
peer.socket = byteToInt(headerBuf, 4);
sendTo(&peer, 24, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case SHARE_APPROVE:
{
/* Client to Dir */
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
/* event fd 클라이언트 소켓 디스크립터 번호 */
sendTo(&dirServ, 25, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case SHARE_DENY:
{
/* Client to Dir */
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
/* event fd 클라이언트 소켓 디스크립터 번호 */
sendTo(&dirServ, 26, event_fd, strlen((char *) dataBuf), dataBuf);
printf("Share refuse Send!!!!!!!!!!!\n");
break;
}
case SHARE_CANCEL:
{
/* Client to Dir */
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
/* event fd 클라이언트 소켓 디스크립터 번호 */
sendTo(&dirServ, 27, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
/* Transmit 프로토콜 30~49 */
case DIR_TO_HDFS_FOR_UPLOAD_METADATA:
{
Peer hdfs;
hdfs.socket = g_epoll_HDFS;
if(g_epoll_HDFS == 0)
{
printf("HDFS server not running \n");
break;
}
sendTo(&hdfs, 30, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
/* 메타데이터 패쓰의 설정을 위해 사용 */
case HDFS_TO_DIR_FOR_MODIFY_METAPATH:
{
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
sendTo(&dirServ, 31, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case DIR_TO_HDFS_FOR_DOWNLOAD_METADATA:
{
Peer hdfs;
hdfs.socket = g_epoll_HDFS;
if(g_epoll_HDFS == 0)
{
printf("HDFS server not running \n");
break;
}
sendTo(&hdfs, 32, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case HDFS_TO_DIR_FOR_SEND_METADATA:
{
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
sendTo(&dirServ, 33, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
/* passingServ 프로토콜 50~100 */
case PROGRAM_EXIT_REQUEST:
{
Peer client;
client.socket = event_fd;
sendTo(&client, PROGRAM_EXIT_RESPONSE, event_fd, strlen((char *) dataBuf), dataBuf);
userpool_delete(event_fd, peer);
close(client.socket);
break;
}
case IDCHECK_REQUEST:
{
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
/* event fd 클라이언트 소켓 디스크립터 번호 */
sendTo(&dirServ, 19, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case IDCHECK_RESPONSE:
{
Peer peer;
peer.socket = byteToInt(headerBuf, 4);
sendTo(&peer, 20, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
/***********************************/
/* 파일 및 폴더 삭제 관련 프로토콜 */
/***********************************/
case DEL_DIR_REQUEST:
{
/* Client to Dir */
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
/* event fd 클라이언트 소켓 디스크립터 번호 */
sendTo(&dirServ, 28, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
case DEL_FILE_REQUEST:
{
/* Client to Dir */
Peer dirServ;
dirServ.socket = g_epoll_dir;
if(g_epoll_dir == 0)
{
printf("dir server not running \n");
break;
}
/* event fd 클라이언트 소켓 디스크립터 번호 */
sendTo(&dirServ, 29, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
/***********************************/
/* 인증 서버 접속관련 프로토콜 */
/***********************************/
case AUTH_BINDING :
{
if(g_epoll_auth == 0)
printf("Auth Serv Binding \n");
else{
printf("Auth Serv already Binding \n");
break;
}
g_epoll_auth = event_fd;
Peer auth;
auth.socket = g_epoll_auth;
sendTo(&auth, 104, event_fd , strlen((char *) dataBuf), dataBuf);
printf("Auth Serv Binding End \n");
break;
}
case DIR_BINDING :
{
if(g_epoll_dir == 0)
printf("Dir Serv Binding \n");
else
{
printf("Dir Serv already Binding \n");
break;
}
g_epoll_dir = event_fd;
Peer dir;
dir.socket = g_epoll_dir;
sendTo(&dir, 105, event_fd, strlen((char *)dataBuf), dataBuf);
printf("Dir Serv Binding End \n");
break;
}
case HDFS_BINDING :
{
g_epoll_HDFS = event_fd;
Peer HDFS;
HDFS.socket = g_epoll_HDFS;
sendTo(&HDFS, 106, event_fd, strlen((char *) dataBuf), dataBuf);
break;
}
/* HandShake Protocol */
/* */
default :
{
printf("type is : %d ", type);
printf("default : %s\n", dataBuf);
break;
}
}
}
void client_recv(int event_fd, Peer *peer)
{
unsigned char headerBuf[HEADERSIZE];
unsigned char dataBuf[DATASIZE];
int len;
memset(headerBuf, 0x00, HEADERSIZE);
memset(dataBuf, 0x00, DATASIZE);
Peer t_peer;
t_peer.socket = event_fd;
printf("recv start \n");
len = recvFrom(&t_peer, headerBuf, dataBuf);
int type = byteToInt(headerBuf, 0);
printf("read end type : %d\n", type);
if( len < 0 || len == 0 )
{
userpool_delete(event_fd, peer);
close(event_fd);
return;
}
printf("start type classify\n");
switch(type)
{
case 0 :
{
//userpool_send(headerBuf, peer);
//userpool_send(dataBuf, peer);
break;
}
case 1 :
{
Peer auth;
auth.socket = g_epoll_auth;
if(g_epoll_auth == 0)
{
//Exception
printf("auth server not running \n");
break;
}
printf("login request to : %d, %d, %s \n", auth.socket, strlen(dataBuf), dataBuf);
sendTo(&auth, 1, event_fd, strlen(dataBuf), dataBuf);
break;
}
case 101 :
{
printf("Auth Serv Binding \n");
g_epoll_auth = event_fd;
printf("Auth Serv fd is : %d \n", event_fd);
sendTo(g_epoll_auth, 102, event_fd , strlen(dataBuf), dataBuf);
printf("Auth Serv Binding End \n");
break;
}
case 102 :
{
printf("Dir Serv Binding \n");
}
default :
{
printf("default\n");
}
}
}
int bmpGetRawSize( unsigned char *imgHeader )
{
return byteToInt( imgHeader , BMP_H_RAW_SIZE , 4 );
}
int bmpGetHeight( unsigned char *imgHeader )
{
return byteToInt( imgHeader , BMP_H_HEIGHT , 4 );
}
int bmpGetWidth( unsigned char *imgHeader )
{
return byteToInt( imgHeader , BMP_H_WIDTH , 4 );
}
int bmpGetOffset( unsigned char *imgHeader )
{
return byteToInt( imgHeader , BMP_H_OFFSET , 4 );
}
int bmpGetFileSize( unsigned char *imgHeader )
{
return byteToInt( imgHeader , BMP_H_FILE_SIZE , 4 );
}
uint CMessage::GetSerial() const
{
return BigLittleSwap16(byteToInt(m_Serial,2));
}
