/*! Receive a NetworkMessage. Workes like recv, but buffer and size is
taken from the NetworkMessage
\see Socket::recv
*/
int DgramSocket::recvFrom(NetworkMessage &msg,SocketAddress &from)
{
NetworkMessage::Header hdr;
peek(&hdr,sizeof(hdr));
msg.setSize(osgntohl(hdr.size));
return recvFrom(msg.getBuffer(),msg.getSize(),from);
}
int main(int argc, char *argv[])
{
if (argc < 2) {
perror("argument less");
exit(EXIT_FAILURE);
}
initGrid(argv[1]);
int sfd;
char ip[32];
memset(ip, 0, 32);
int port = 0;
Msg msg_recv;
memset(&msg_recv, 0, sizeof(Msg));
if (atoi(argv[1]) == 1) {
sfd = initUdpServer(IP, PORT);
while (recvFrom(sfd, &msg_recv, sizeof(Msg), ip, &port) != 0) {
hebing(&msg_recv);
if (win(msg_recv)) {
printf("YOU LOSE!\n");
break;
}
move();
sendTo(sfd, &msg, sizeof(Msg), ip, port);
if (win(msg)) {
printf("YOU WIN!\n");
break;
}
}
} else {
sfd = initUdpClient();
while (move(), sendTo(sfd, &msg, sizeof(Msg), IP, PORT) != 0) {
if (win(msg)) {
printf("YOU WIN\n");
break;
}
recvFrom(sfd, &msg_recv, sizeof(Msg), ip, &port);
hebing(&msg_recv);
if (win(msg_recv)) {
printf("YOU LOSE!\n");
break;
}
}
}
close(sfd);
return 0;
}
int Socket::recvFrom(uint8_t *buf, int &len,
struct sockaddr_un &addr, const int flags)
{
if (-1 == m_fd) return EG_INVAL;
socklen_t addrLen[1] = { sizeof(addr) };
return recvFrom(buf, len, flags,
(struct sockaddr *)&addr, addrLen);
}
int Socket::recvFrom(std::string& data, int flags, InetAddress& sinaddr)const
{
char buf[MAX_RECV_SIZE + 1] = { 0 };
while(true)
{
int len = recvFrom(buf, MAX_RECV_SIZE, flags, sinaddr);
if(len == -1 || len == 0)
break;
data.insert(data.end(), buf, buf + len);
if(len < MAX_RECV_SIZE)
break;
}
return data.size();
}
int SocketWrapper::getMessageSize()
{
char b;
struct sockaddr saddr;
bzero(&saddr, sizeof(struct sockaddr));
socklen_t addrlen = sizeof(struct sockaddr);
ssize_t rc = recvFrom(&b, 1, MSG_PEEK | MSG_TRUNC, &saddr, &addrlen);
if (0 >= rc) {
HAGGLE_ERR("Error: could not peek on socket\n");
}
return rc;
}
bool SocketWrapper::peek(struct sockaddr *o_saddr, socklen_t *o_addrlen)
{
if ((NULL == o_saddr) || (NULL == o_addrlen)) {
HAGGLE_ERR("Invalid params\n");
return false;
}
char b;
ssize_t rc = recvFrom(&b, 1, MSG_PEEK, o_saddr, o_addrlen);
if (1 != rc) {
HAGGLE_ERR("Error: could not peek on socket\n");
return false;
}
return true;
}
int SocketWrapper::peek(char *o_buf, int buf_size)
{
if (NULL == o_buf) {
HAGGLE_ERR("Invalid params\n");
return 0;
}
struct sockaddr saddr;
bzero(&saddr, sizeof(struct sockaddr));
socklen_t addrlen = sizeof(struct sockaddr);
ssize_t rc = recvFrom(o_buf, buf_size, MSG_PEEK, &saddr, &addrlen);
if (0 >= rc) {
HAGGLE_ERR("Error: could not peek on socket\n");
}
return rc;
}
ProtocolEvent ProtocolUDP::receiveData(void *buf, size_t buflen, struct sockaddr *peer_addr, const int flags, size_t *bytes)
{
ssize_t ret;
*bytes = 0;
socklen_t addrlen = SOCKADDR_SIZE;
memset(peer_addr, 0, SOCKADDR_SIZE);
ret = recvFrom(buf, buflen, flags, peer_addr, &addrlen);
if (ret < 0) {
return PROT_EVENT_ERROR;
} else if (ret == 0)
return PROT_EVENT_PEER_CLOSED;
*bytes = ret;
return PROT_EVENT_SUCCESS;
}
void
PeerDiscovery::DomainPeerDiscovery::listenerpack_thread()
{
int stopfds_pipe[2];
#ifndef _WIN32
if (pipe(stopfds_pipe) == -1)
throw std::runtime_error(std::string("Can't open pipe: ") + strerror(errno));
#else
net::udpPipe(stopfds_pipe);
#endif
int stop_readfd = stopfds_pipe[0];
stop_writefd_ = stopfds_pipe[1];
while (true) {
fd_set readfds;
FD_ZERO(&readfds);
FD_SET(stop_readfd, &readfds);
FD_SET(sockfd_, &readfds);
int data_coming = select(std::max(sockfd_, stop_readfd) + 1, &readfds, nullptr, nullptr, nullptr);
{
std::unique_lock<std::mutex> lck(dmtx_);
if (not drunning_)
break;
}
if (data_coming < 0) {
if(errno != EINTR) {
perror("Select Error");
std::this_thread::sleep_for( std::chrono::seconds(1) );
}
} else if (data_coming > 0) {
if (FD_ISSET(stop_readfd, &readfds)) {
std::array<uint8_t, 64 * 1024> buf;
recv(stop_readfd, (char*)buf.data(), buf.size(), 0);
}
try {
auto rcv = recvFrom();
msgpack::object obj = rcv.second.get();
if (obj.type != msgpack::type::MAP)
continue;
for (unsigned i = 0; i < obj.via.map.size; i++) {
auto& o = obj.via.map.ptr[i];
if (o.key.type != msgpack::type::STR)
continue;
auto key = o.key.as<std::string>();
ServiceDiscoveredCallback cb;
{
std::lock_guard<std::mutex> lck(dmtx_);
auto callback = callbackmap_.find(key);
if (callback != callbackmap_.end())
cb = callback->second;
}
if (cb)
cb(std::move(o.val), std::move(rcv.first));
}
} catch (const std::exception& e) {
std::cerr << "Error receiving packet: " << e.what() << std::endl;
}
}
}
if (stop_readfd != -1)
close(stop_readfd);
if (stop_writefd_ != -1) {
close(stop_writefd_);
stop_writefd_ = -1;
}
}
int
main(void)
{
int sockfd, new_fd; // listen on sock_fd, new connection on new_fd
struct addrinfo hints, *servinfo, *p;
struct sockaddr_storage their_addr; // connector's address information
socklen_t sin_size;
struct sigaction sa;
int yes=1;
char s[INET6_ADDRSTRLEN];
int rv;
pid_t childPID; //control variable for multithreading
//char send_buf[MAX_SEND_BUF_LENGTH];
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE; // use my IP
//For debugging
FILE *file;
file = fopen("file_server.txt", "w");
fprintf(file,"%s","Top of the file");
//
if ((rv = getaddrinfo(NULL, PORT, &hints, &servinfo)) != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}
// loop through all the results and bind to the first we can
for(p = servinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror("server: socket");
continue;
}
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes,
sizeof(int)) == -1) {
perror("setsockopt");
exit(1);
}
if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
close(sockfd);
perror("server: bind");
continue;
}
break;
}
if (p == NULL) {
fprintf(stderr, "server: failed to bind\n");
return 2;
}
freeaddrinfo(servinfo); // all done with this structure
if (listen(sockfd, BACKLOG) == -1) {
perror("listen");
exit(1);
}
sa.sa_handler = sigchld_handler; // reap all dead processes
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa, NULL) == -1) {
perror("sigaction");
exit(1);
}
printf("server: waiting for connections...\n");
while(1) { // main accept() loop
sin_size = sizeof their_addr;
new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
if (new_fd == -1) {
perror("accept");
continue;
}
inet_ntop(their_addr.ss_family,
get_in_addr((struct sockaddr *)&their_addr),
s, sizeof s);
printf("server: got connection from %s\n", s);
//fprintf(file,"%s","server: got connection from");
//fprintf(file,"%s\n",s);
//Threading
childPID=fork();
if(childPID>=0)
{
if(childPID == 0){ //Child process
close(sockfd); // child doesn't need the listener
//Send "WDW?"; What do you want?
sendTo(new_fd, "WDW?");
recvFrom(new_fd);
nofChunksToSend=atoi(recv_buf);
//send the bulk data to the client
unsigned int nof_chunksent=0;
while(nof_chunksent < nofChunksToSend){
strcpy(send_buf, "Hello World birader");
sprintf(temp_buffer, "%d", nof_chunksent);
strcat(send_buf, temp_buffer);
//printf("send_buf: %s\n", send_buf);
//send send_buf to receiver
if (sendTo(new_fd, send_buf) == 1){
++nof_chunksent;
}
memset(send_buf, 0, MAXSENDLENGTH);//Initialize for the next chunk sending session
memset(temp_buffer, 0, 10);
}//All bulk data sent, close the socket
close(new_fd);
fclose(file);
exit(0);
}
else{//parent process
close(new_fd); // parent doesn't need this
//Listen the channel by inf while
}
}
else{
printf("\n Fork failed, exit !\n");
return 1;
}
}
fclose(file); /*done!*/
return 0;
}
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;
}
}
}
int main(int argc, char *argv[])
{
//For debugging
file = fopen("file_g_s.txt", "w");
fprintf(file,"%s","Top of the file");
//
//char send_buf[MAX_SEND_BUF_LENGTH];
set_dsanode_ids();
serverSocketStuff();
printf("gateway_s: waiting for connections...\n");
while(1) { // main accept() loop
sin_size = sizeof their_addr;
new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
if (new_fd == -1) {
perror("accept");
continue;
}
inet_ntop(their_addr.ss_family,get_in_addr((struct sockaddr *)&their_addr),s, sizeof s);
printf("gateway_s: got connection from %s\n", s);
//fprintf(file,"%s","server: got connection from");
//fprintf(file,"%s\n",s);
//Threading
childPID=fork();
if(childPID>=0)
{
if(childPID == 0){ //Child process
close(sockfd); // child doesn't need the listener
//Wait for #ofChunks:X message from p
recvFrom(new_fd, 0);
char subbuff[10];
memcpy( subbuff, recv_buff, 10 );
subbuff[10] = '\0';
if(strcmp(subbuff, "#ofChunks:")==0){
sendTo(new_fd, "OK"); //the # of chunks that client desires to get
}
else{
printf("Recved irrelevant message:%s\n", recv_buff);
exit(1);
}
//send the bulk data to the client
strncpy(subbuff, recv_buff+strlen("#ofChunks:"), (strlen(recv_buff)-strlen("#ofChunks:")));
nofChunksToRecv=atoi(subbuff);
printf("nofChunksToRecv:%d\n", nofChunksToRecv);
while(1){
numbytes=recvFrom(new_fd, 0);
fprintf(file, "\nnumbytes recved: %d",numbytes);
//printf("GW RECEIVED: '%s'\n",recv_buff);
fprintf(file,"\n%s",recv_buff);
pthread_join(tt,NULL); //Wait for the previous thread to finish
strcat(send_buff, recv_buff);//buffer all the data to be sent to dsa stage
//Instead of writing the recved data to a file send the data to the staging nodes
int rc = pthread_create(&tt, NULL, sendToStage, NULL);
if (rc){
printf("ERROR; return code from pthread_create() is %d\n", rc);
exit(-1);
}
memset(recv_buff, 0, MAXRECVLENGTH);
}
}
else{//parent process
close(new_fd); // parent doesn't need this
//Listen the channel by inf while
}
}
else{
printf("\n Fork failed, exit !\n");
return 1;
}
}
fclose(file); /*done!*/
return 0;
}
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");
}
}
}
