static unsigned long
SendRequest(u_size op_code,u_size total_objects,void *packet, u_size size)
{
header_t header;
void *to_send;
int socket;
int ret;
ack_t *ack_ptr;
void *data;
u_size header_size;
/* Tipo de pedido */
header.opCode = op_code;
header.total_objects = total_objects;
/* Identificacion del usuario */
strcpy(header.user,log_user);
strcpy(header.passwd,log_passwd);
header_size = GetHeaderData(header, &data);
/* Concateno los paquetes header y pedido */
if( (to_send = malloc(header_size+size)) == NULL )
return CONNECT_ERROR;
memmove(to_send, data, header_size);
free(data);
/* Chequeo si realmente se manda un paquete asociado al pedido */
if( packet != NULL ) {
memmove(to_send+header_size, packet, size);
}
/* Me conecto al servidor */
if( (socket=connectTCP(server_host,server_port)) < 0 ){
free(to_send);
return CONNECT_ERROR;
}
setSocketTimeout(socket,TIMEOUT_DEFAULT);
/* Mando el paquete */
sendTCP(socket, to_send,header_size+size);
free(to_send);
if(exitPipe==1)
{
exitPipe=0;
close(socket);
return TIMEOUT_ERROR;
}
/* Espero por la respuesta del servidor */
ack_ptr = receiveTCP(socket);
if(ack_ptr==NULL)
{
close(socket);
return TIMEOUT_ERROR;
}
ret = ack_ptr->ret_code;
free(ack_ptr);
/* Cierro la conexion????? */
close(socket);
return ret;
}
bool send( PacketContainer& cont ) {
cont.getPacket()->setOriginAddr( m_origin );
// set timeout, convert from ms to sec, round up
cont.getPacket()->
setTimeout( ( 999 + cont.getNextResendTimeout() ) / 1000 );
// Set destination, i.e. the multicast address of the leader
// of the correct module type and mapSet.
IPnPort dest;
cont.getIPAndPort( dest.first, dest.second );
if ( cont.getPacket()->getLength() < m_tcpLimit ) {
IPnPort tcpDest = getLeaderAddr( dest );
if ( tcpDest.getIP() != 0 ) {
sendTCP( cont.getPacket()->getClone(), tcpDest );
return true;
}
return sendPacket( cont.getPacket()->getClone(), dest );
} else {
LeaderIPRequestPacket* req =
new LeaderIPRequestPacket( cont.getModuleType(),
static_cast< RequestPacket& >
( *cont.getPacket() ),
dest );
req->setOriginAddr( m_origin );
IPnPort tcpDest = getLeaderAddr( dest );
if ( tcpDest.getIP() != 0 ) {
mc2dbg2 << "Sending leader ip as tcp" << endl;
mc2dbg2 << "to destination: " << tcpDest << endl;
sendTCP( req, tcpDest );
return true;
}
mc2dbg2 << "Sending leader ip as udp" << endl;
mc2dbg2 << "to destination: " << dest << endl;
return sendPacket( req, dest );
}
return true;
}
static download_header_t
SendDownloadRequest(void *packet, u_size size)
{
header_t header;
void *to_send;
int socket;
download_header_t download_info;
void *data;
u_size header_size;
void *ack_data;
download_info.ret_code = CONNECT_ERROR;
/* Tipo de pedido */
header.opCode = __DOWNLOAD__;
header.total_objects = 1;
/* Identificacion del usuario */
strcpy(header.user,log_user);
strcpy(header.passwd,log_passwd);
header_size = GetHeaderData(header, &data);
/* Concateno los paquetes header y pedido */
if( (to_send = malloc(header_size+size)) == NULL )
return download_info;
memmove(to_send, data, header_size);
memmove(to_send+header_size, packet, size);
free(data);
/* Me conecto al servidor */
if( (socket=connectTCP(server_host,server_port)) < 0 ){
free(to_send);
return download_info;
}
setSocketTimeout(socket,TIMEOUT_DEFAULT);
/* Mando el paquete */
sendTCP(socket, to_send,header_size+size);
free(to_send);
if(exitPipe==1)
{
exitPipe=0;
close(socket);
return download_info;
}
/* Espero por la respuesta del servidor */
ack_data = receiveTCP(socket);
if(ack_data==NULL)
{
close(socket);
return download_info;
}
GetDownloadHeaderPack(ack_data, &download_info);
/* Cierro la conexion????? */
close(socket);
return download_info;
}
// Send current SUI state to master.
void ServerNForm::updateMaster()
{
stUI2MA_DATA data;
memcpy(&data, &UI2Madata, sizeof(stUI2MA_DATA));
if( keypad->getStatus() != KP_HIDE_AUTHORIZED ){
// set zeros
data.scale = 0;
data.tick = 0;
}
data.checksum = checksumUI2MA(&data);
sendTCP(&data);
return;
}
static status
SendSignal(u_size op_code, void *packet, u_size size)
{
header_t header;
void *to_send;
int socket;
u_size header_size;
void *data;
/* Tipo de senial */
header.opCode = op_code;
header.total_objects = 1;
/* Identificacion del usuario */
strcpy(header.user,log_user);
strcpy(header.passwd,log_passwd);
/* Concateno los paquetes header y pedido */
header_size = GetHeaderData(header, &data);
if( (to_send = malloc(header_size+size)) == NULL )
return ERROR;
memmove(to_send, data, header_size);
memmove(to_send + header_size,packet,size);
free(data);
/* Me conecto al servidor */
if( (socket=connectTCP(server_host,server_port)) < 0 ){
free(to_send);
return ERROR;
}
setSocketTimeout(socket,TIMEOUT_DEFAULT);
/* Mando el paquete */
sendTCP(socket, to_send,header_size+size);
free(to_send);
if(exitPipe==1)
{
exitPipe=0;
close(socket);
return ERROR;
}
close(socket);
return OK;
}
int create_connection(struct udps_config_t *config, const u_int16_t srcport, struct usock_t *usock) {
struct sockaddr_in socks5_server;
void *socks_req = NULL;
void *response = NULL;
int i, len, res;
fd_set set;
time_t t;
if ((usock->sk = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
printf("socket() failure\n");
return ERR;
}
fcntl(usock->sk, F_SETFL, O_NONBLOCK);
memset(&socks5_server, 0, sizeof(struct sockaddr_in)); /* Clear struct */
socks5_server.sin_family = AF_INET; /* Internet/IP */
socks5_server.sin_addr.s_addr = usock->connect_ip; /* IP address */
socks5_server.sin_port = htons(usock->connect_port); /* Server port */
/* Establish connection */
t = time(NULL);
printf("DEBUG: new connection at time %s\n", ctime(&t));
if (connect(usock->sk, (struct sockaddr *)&socks5_server, sizeof(socks5_server)) < 0) {
while (1) {
if (errno == EINPROGRESS) {
FD_ZERO(&set);
FD_SET(usock->sk, &set);
if (select(usock->sk + 1, NULL, &set, NULL, NULL) <= 0)
break;
if (FD_ISSET(usock->sk, &set))
break;
continue;
}
else {
printf("connect() failure\n");
goto SOCK_ERR;
}
}
}
/* Send authentification methods supported */
socks_req = malloc(sizeof(struct socks5_methods));
memset(socks_req, 0, sizeof(struct socks5_methods));
((struct socks5_methods *)socks_req)->nmethods = 0;
((struct socks5_methods *)socks_req)->ver = SOCKS_VERSION;
for (i=0; i < SOCKS5_METHOD_IMPLEMENTED; i++) {
((struct socks5_methods *)socks_req)->methods[i] = socks5_method_implemented[i];
((struct socks5_methods *)socks_req)->nmethods++;
}
len = LEN_SOCKS5_METHODS + SOCKS5_METHOD_IMPLEMENTED;
res = sendTCP(usock->sk, len, socks_req);
if (res <= 0) {
t = time(NULL);
printf("DEBUG: sendTCP() failure at %s\n", ctime(&t));
if (res == 0)
printf("closed connection\n");
if (res == -2)
printf("select() timed out\n");
free(socks_req);
goto SOCK_ERR;
}
free(socks_req);
response = malloc(SOCKS5_AUTH_REPLY);
memset(response, 0, SOCKS5_AUTH_REPLY);
res = recvTCP(usock->sk, SOCKS5_AUTH_REPLY, response);
if (res <= 0) {
t = time(NULL);
printf("DEBUG: recvTCP() failure at %s\n", ctime(&t));
if (res == 0)
printf("closed connection\n");
if (res == -2)
printf("select() timed out\n");
free(response);
goto SOCK_ERR;
}
switch (((struct socks5_auth_reply *)response)->status) {
case NO_AUTH_REQ:
/* ok, now send directly the request */
break;
case USER_PWD:
/* creating request for authentication */
printf("Authorization required!\n");
socks_req = malloc(sizeof(struct socks5_auth_req));
memset(socks_req, 0, sizeof(struct socks5_auth_req));
((struct socks5_auth_req *)socks_req)->ver = CMD_AUTH;
/* Copy user_name */
((struct socks5_auth_req *) socks_req)->ulen = min(MAX_UNAME, strlen(config->user));
memset(((struct socks5_auth_req *) socks_req)->uname_plen_password, 0, 2 * MAX_UNAME + 1);
memcpy(((struct socks5_auth_req *) socks_req)->uname_plen_password,
config->user, ((struct socks5_auth_req *) socks_req)->ulen);
/* Copy password */
((struct socks5_auth_req *)socks_req)->uname_plen_password[((struct socks5_auth_req *)socks_req)->ulen] = min(MAX_UNAME, strlen(config->passwd));
memcpy(&(((struct socks5_auth_req *)socks_req)->uname_plen_password[((struct socks5_auth_req *)socks_req)->ulen + 1]),
config->passwd, ((struct socks5_auth_req *)socks_req)->uname_plen_password[((struct socks5_auth_req *)socks_req)->ulen]);
len = LEN_SOCKS5_AUTH_REQ + ((struct socks5_auth_req *)socks_req)->ulen +
((struct socks5_auth_req *)socks_req)->uname_plen_password[((struct socks5_auth_req *)socks_req)->ulen];
if (sendTCP(usock->sk, len, socks_req) <= 0) {
free(socks_req);
goto SOCK_ERR;
}
free(socks_req);
response = malloc(SOCKS5_AUTH_REPLY);
memset(response, 0, SOCKS5_AUTH_REPLY);
if (recvTCP(usock->sk, SOCKS5_AUTH_REPLY, response) <= 0) {
free(response);
goto SOCK_ERR;
}
if (((struct socks5_auth_reply *)response)->status != 0) {
printf("Authorization on socks5 server failed!\n");
goto SOCK_ERR;
}
break;
default:
printf("wrong auth method\n");
goto SOCK_ERR; /* Something wrong */
} /* switch */
/* auth step is fine, now can send request */
socks_req = malloc(sizeof(struct socks5_req));
memset(socks_req, 0, sizeof(struct socks5_req));
((struct socks5_req *)socks_req)->ver = SOCKS_VERSION;
((struct socks5_req *)socks_req)->cmd = UDP_ASSOCIATE;
((struct socks5_req *)socks_req)->rsv = RSV;
((struct socks5_req *)socks_req)->atyp = ATYP_V4;
/* Formerly we want send data from same ip that control connection */
//((struct socks5_req *)socks_req)->dst_ip = inet_addr("0.0.0.0");
((struct socks5_req *)socks_req)->dst_ip = config->nat_ip;
((struct socks5_req *)socks_req)->dstport = srcport;
/* send connection request */
res = sendTCP(usock->sk, LEN_SOCKS5_REQ, socks_req);
if (res <= 0) {
t = time(NULL);
printf("DEBUG: sendTCP(2) failure at %s\n", ctime(&t));
if (res == 0)
printf("closed connection\n");
if (res == -2)
printf("select() timed out\n");
free(socks_req);
goto SOCK_ERR;
}
free(socks_req);
response = malloc(SOCKS5_UDP_REPLY);
memset(response, 0, SOCKS5_UDP_REPLY);
res = recvTCP(usock->sk, SOCKS5_UDP_REPLY, response);
if (res <= 0) {
t = time(NULL);
printf("DEBUG: recvTCP(2) failure at %s\n", ctime(&t)); /* Proxy close control connection */
if (res == 0)
printf("closed connection\n");
if (res == -2)
printf("select() timed out\n");
free(response);
goto SOCK_ERR;
}
usock->sk_ip = ((struct socks5_req *)response)->dst_ip;
usock->sk_port = ((struct socks5_req *)response)->dstport;
free(response);
return OK;
SOCK_ERR:
close(usock->sk);
usock->sk = 0;
return ERR;
}
static int
SendListMoviesRequest(void *data, u_size size, movie_t ***out_ptr)
{
header_t header;
header_t ack_header;
void *ack_movies;
void *to_send;
void * ackHeader;
int socket;
void *header_data;
u_size header_size;
/* Tipo de pedido */
header.opCode = __LIST_MOVIES_BY_GEN__;
header.total_objects = 1;
/* Identificacion del usuario */
strcpy(header.user,log_user);
strcpy(header.passwd,log_passwd);
header_size = GetHeaderData(header, &header_data);
/* Concateno los paquetes header y pedido */
if( (to_send = malloc(header_size+size)) == NULL )
return CONNECT_ERROR;
memmove(to_send, header_data, header_size);
free(header_data);
/* Chequeo si realmente se manda un paquete asociado al pedido */
memmove(to_send+header_size, data, size);
/* Me conecto al servidor */
if( (socket=connectTCP(server_host,server_port)) < 0 ){
free(to_send);
return -1;
}
setSocketTimeout(socket,TIMEOUT_DEFAULT);
/* Mando el paquete */
sendTCP(socket, to_send,header_size+size);
free(to_send);
if(exitPipe==1)
{
exitPipe=0;
close(socket);
return TIMEOUT_ERROR;
}
/* Espero por la respuesta del servidor */
ackHeader=receiveTCP(socket);
if(ackHeader==NULL)
{
close(socket);
return TIMEOUT_ERROR;
}
GetHeaderPack(ackHeader,&ack_header);
fflush(stdout);
if( ack_header.opCode == __LIST_OK__ ) {
ack_movies = receiveTCP(socket);
if(ack_movies==NULL)
{
close(socket);
return TIMEOUT_ERROR;
}
*out_ptr = GetMovies(ack_movies,ack_header.total_objects);
free(ack_movies);
}
else
ack_header.total_objects = 0;
close(socket);
return ack_header.total_objects;
}
static int
SendListUsersRequest(client_t ***out_ptr)
{
header_t header;
header_t ack_header;
void *ack_users;
void * ackHeader;
int socket;
void *header_data;
u_size header_size;
char * decripted;
/* Tipo de pedido */
header.opCode = __LIST_USERS__;
header.total_objects = 1;
/* Identificacion del usuario */
strcpy(header.user,log_user);
strcpy(header.passwd,log_passwd);
header_size = GetHeaderData(header, &header_data);
/* Me conecto al servidor */
if( (socket=connectTCP(server_host,server_port)) < 0 ){
free(header_data);
return -1;
}
setSocketTimeout(socket,TIMEOUT_DEFAULT);
/* Mando el paquete */
sendTCP(socket, header_data,header_size);
free(header_data);
if(exitPipe==1)
{
exitPipe=0;
close(socket);
return -1;
}
/* Espero por la respuesta del servidor */
ackHeader=receiveTCP(socket);
if(ackHeader==NULL)
{
close(socket);
return -1;
}
GetHeaderPack(ackHeader,&ack_header);
if( ack_header.opCode == __LIST_USERS_OK__ ) {
ack_users = receiveTCP(socket);
if(ack_users==NULL)
{
close(socket);
return -1;
}
decripted=Decypher(ack_users,ack_header.total_objects*(MAX_USER_LEN+MAX_USER_MAIL+MAX_USER_DESC+sizeof(unsigned char)),log_passwd);
*out_ptr = GetUsersList(decripted,ack_header.total_objects);
free(decripted);
free(ack_users);
}
else {
if( ack_header.opCode == __USER_ACCESS_DENY__ || ack_header.opCode == __USER_IS_NOT_LOG__ )
return -2;
else
return -1;
}
close(socket);
return ack_header.total_objects;
}
static int
SendListGensRequest(list_movie_request_t ***out_ptr)
{
header_t header;
header_t ack_header;
void *ack_gens;
void * dataAux;
int socket;
void *header_data;
u_size header_size;
/* Tipo de pedido */
header.opCode = __LIST_GENS__;
header.total_objects = 1;
/* Identificacion del usuario */
strcpy(header.user,log_user);
strcpy(header.passwd,log_passwd);
header_size = GetHeaderData(header, &header_data);
/* Me conecto al servidor */
if( (socket=connectTCP(server_host,server_port)) < 0 ){
free(header_data);
return -1;
}
setSocketTimeout(socket,TIMEOUT_DEFAULT);
/* Mando el paquete */
sendTCP(socket, header_data,header_size);
free(header_data);
if(exitPipe==1)
{
exitPipe=0;
close(socket);
return -1;
}
/* Espero por la respuesta del servidor */
dataAux=receiveTCP(socket);
if(dataAux==NULL)
{
close(socket);
return -1;
}
GetHeaderPack(dataAux,&ack_header);
if( ack_header.opCode == __LIST_OK__ ) {
ack_gens = receiveTCP(socket);
if(ack_gens==NULL)
{
close(socket);
return -1;
}
*out_ptr = GetGenList(ack_gens,ack_header.total_objects);
free(ack_gens);
}
else {
return -1;
}
close(socket);
return ack_header.total_objects;
}
