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; }