void msg_listar_servicos_handler(int socket, mensagem_s *msg)
{
if (msg->size < HEADER_SIZE + 4)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_LISTAR_SERVICOS\n");
int token = msg_recv_int(msg);
mensagem_s * s = preparePacket(SMSG_LISTAR_SERVICOS_PAGAMENTO_RESPONSE);
//obter a session activa
Session *session = GetSession(token);
if (session && session->sessionExpire >= currTime)
{
int total = 0;
msg_put_short(ERROR_CODE_SUCCESS, s);
msg_put_int(0, s);
for (LinkedListNode * p = Begin(dbServicos); p != NULL; p = Next(p))
{
Servico * servico = p->element;
msg_put_int(servico->id, s);
msg_put_string(servico->nome, s);
total += 1;
}
msg_put_int_at(5, total, s);
}
else
{
msg_put_short(ERROR_CODE_SESSAO_EXPIROU, s);
}
finalizePacket(s);
sendData(socket, s);
free(s);
}
void msg_criar_novo_servico_handler(int socket, mensagem_s *msg)
{
if (msg->size < HEADER_SIZE + 4 + 4 + 1)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_CRIAR_NOVO_SERVICO\n");
int token = msg_recv_int(msg);
mensagem_s * s = preparePacket(SMSG_CRIAR_NOVO_SERVICO_RESPONSE);
//obter a session activa
Session *session = GetSession(token);
if (session && session->sessionExpire >= currTime)
{
if (session->cliente->flags == ACCESS_LEVEL_ADMIN || session->cliente->flags == ACCESS_LEVEL_CLIENTE)
{
msg_put_short(ERROR_CODE_TIPO_CONTA_INVALIDA, s);
}
else
{
char * nomeServico = msg_recv_string(msg);
int nib = msg_recv_int(msg);
//verificacao minima do nome de servico
if (strlen(nomeServico) == 0 || strlen(nomeServico) > 255)
{
msg_put_short(ERROR_CODE_NOME_SERVICO_INVALIDO, s);
}
else
{
Servico *servico = malloc(sizeof(Servico));
Conta *contaD = GetConta(nib);
if (contaD)
{
servico->id = genServicoID();
servico->nib = nib;
strcpy(servico->nome, nomeServico);
ServicoAdd(servico);
msg_put_short(ERROR_CODE_SUCCESS, s);
}
else
{
msg_put_short(ERROR_CODE_NIB_INVALIDO, s);
}
}
free(nomeServico);
}
}
else
{
msg_put_short(ERROR_CODE_SESSAO_EXPIROU, s);
}
finalizePacket(s);
sendData(socket, s);
free(s);
}
void msg_consultar_movimentos_handler(int socket, mensagem_s *msg)
{
if (msg->size < HEADER_SIZE + 4 + 4)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_CONSULTAR_MOVIMENTOS\n");
int token = msg_recv_int(msg);
mensagem_s * s = preparePacket(SMSG_CONSULTAR_MOVIMENTOS_RESPONSE);
//obter a session activa
Session *session = GetSession(token);
if (session && session->sessionExpire >= currTime)
{
if (session->cliente->flags == ACCESS_LEVEL_ADMIN)
{
msg_put_short(ERROR_CODE_TIPO_CONTA_INVALIDA, s);
}
else
{
int contaId = msg_recv_int(msg);
Conta *conta = GetConta(contaId);
if (conta && conta->clientID == session->cliente->id)
{
msg_put_short(ERROR_CODE_SUCCESS, s);
msg_put_int(0, s);
unsigned char total = 0;
for (LinkedListNode * p = Begin(dbMovimentos); p != NULL; p = Next(p))
{
Movimento * movimento = p->element;
if (movimento->owner == contaId && total < 256)
{
msg_put_byte(movimento->tipo, s);
msg_put_int(movimento->Montante, s);
msg_put_int(movimento->contaO, s);
msg_put_int(movimento->ContaD, s);
total += 1;
}
}
msg_put_int_at(5, total, s);
}
else
{
msg_put_short(ERROR_CODE_CONTA_INVALIDA, s);
}
}
}
else
{
msg_put_short(ERROR_CODE_SESSAO_EXPIROU, s);
}
finalizePacket(s);
sendData(socket, s);
free(s);
}
void msg_listar_entidades_handler(int socket, mensagem_s *msg)
{
if (msg->size < HEADER_SIZE + 4)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_LISTAR_ENTIDADES\n");
int token = msg_recv_int(msg);
mensagem_s * s = preparePacket(SMSG_LISTAR_ENTIDADES_RESPONSE);
//obter a session activa
Session *session = GetSession(token);
if (session && session->sessionExpire >= currTime)
{
if (session->cliente->flags == ACCESS_LEVEL_ENTIDADE || session->cliente->flags == ACCESS_LEVEL_CLIENTE)
{
msg_put_short(ERROR_CODE_TIPO_CONTA_INVALIDA, s);
}
else
{
int total = 0;
msg_put_short(ERROR_CODE_SUCCESS, s);
msg_put_int(0, s);
for (LinkedListNode * p = Begin(dbUtilizadores); p != NULL; p = Next(p))
{
Utilizador * cliente = p->element;
if (cliente->flags == ACCESS_LEVEL_ENTIDADE)
{
msg_put_string(cliente->username, s);
int saldo = 0;
for (LinkedListNode * p2 = Begin(dbContas); p2 != NULL; p2 = Next(p2))
{
Conta *conta = p2->element;
if (conta->clientID == cliente->id)
{
saldo += conta->saldo;
}
}
msg_put_int(saldo, s);
total += 1;
}
}
msg_put_int_at(5, total, s);
}
}
else
{
msg_put_short(ERROR_CODE_SESSAO_EXPIROU, s);
}
finalizePacket(s);
sendData(socket, s);
free(s);
}
void msg_registo_handler(int socket, mensagem_s *msg)
{
//header + str + str + int
if (msg->size < HEADER_SIZE + 1 + 1 + 4)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_REGISTO\n");
char *username = msg_recv_string(msg);
char *password = msg_recv_string(msg);
Utilizador * c = GetCliente(username);
mensagem_s * s = preparePacket(SMSG_REGISTO_RESPONSE);
if (c != NULL)
{
msg_put_short(ERROR_CODE_NOME_UTILIZADOR_OU_PASS_INVALIDA, s);
}
else
{
//actualizar a base de dados
Utilizador * newCliente = malloc(sizeof(Utilizador));
int acesso = msg_recv_int(msg);
if ((!StringValida(password, 31)) || (!StringValida(username, 31)) ||
acesso < ACCESS_LEVEL_CLIENTE || acesso > ACCESS_LEVEL_ADMIN )
{
msg_put_short(ERROR_CODE_NOME_UTILIZADOR_OU_PASS_INVALIDA, s);
}
else
{
newCliente->flags = acesso;
newCliente->id = genUtilizadorID();
newCliente->congelada = false;
strcpy(newCliente->password, password);
strcpy(newCliente->username, username);
UtilizadorAdd(newCliente);
msg_put_short(ERROR_CODE_SUCCESS, s);
}
}
free(username);
free(password);
finalizePacket(s);
sendData(socket, s);
free(s);
}
void msg_criar_conta_handler(int socket, mensagem_s *msg)
{
if (msg->size < HEADER_SIZE + 4)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_CRIAR_CONTA\n");
int token = msg_recv_int(msg);
mensagem_s * s = preparePacket(SMSG_CRIAR_CONTA_RESPONSE);
//obter a session activa
Session *session = GetSession(token);
if (session && session->sessionExpire >= currTime)
{
if (session->cliente->flags == ACCESS_LEVEL_ADMIN)
{
msg_put_short(ERROR_CODE_TIPO_CONTA_INVALIDA, s);
}
else
{
Conta *conta = malloc(sizeof(Conta));
conta->clientID = session->cliente->id;
conta->contaID = genAccountID();
conta->saldo = 1000;
ContasAdd(conta);
Movimento *movimentoO = malloc(sizeof(Movimento));
movimentoO->owner = conta->contaID;
movimentoO->contaO = conta->contaID;
movimentoO->ContaD = conta->contaID;
movimentoO->id = genMovimentoID();
movimentoO->Montante = 1000;
movimentoO->tipo = TIPO_MOVIMENTO_CREDITO;
MovimentoAdd(movimentoO);
msg_put_short(ERROR_CODE_SUCCESS, s);
}
}
else
{
msg_put_short(ERROR_CODE_SESSAO_EXPIROU, s);
}
finalizePacket(s);
sendData(socket, s);
free(s);
}
void msg_login_handler(int socket, mensagem_s *msg)
{
//header + str + str
if (msg->size < HEADER_SIZE + 1 + 1)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_LOGIN\n");
char *username = msg_recv_string(msg);
char *password = msg_recv_string(msg);
mensagem_s * s = preparePacket(SMSG_LOGIN_RESPONSE);
Utilizador * c = GetCliente(username);
if (c)
{
if (c->congelada)
{
msg_put_short(ERROR_CODE_CONTA_CONGELADA, s);
}
else if (strcmp(password, c->password) == 0)
{
Session *session = malloc(sizeof(Session));
session->cliente = c;
session->token = genToken();
session->sessionExpire = time(NULL) + 1 *60 * 10;
SessionAdd(session);
msg_put_short(ERROR_CODE_SUCCESS, s);
msg_put_int(session->token, s);
msg_put_byte(c->flags, s);
}
else
{
msg_put_short(ERROR_CODE_NOME_UTILIZADOR_OU_PASS_INVALIDA, s);
}
}
else
{
msg_put_short(ERROR_CODE_NOME_UTILIZADOR_OU_PASS_INVALIDA, s);
}
free(username);
free(password);
finalizePacket(s);
sendData(socket, s);
free(s);
}
void msg_listar_contas_proprias_handler(int socket, mensagem_s *msg)
{
if (msg->size < HEADER_SIZE + 4)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_LISTAR_CONTAS_PROPRIAS\n");
int token = msg_recv_int(msg);
mensagem_s * s = preparePacket(SMSG_LISTAR_CONTAS_PROPRIAS_RESPONSE);
//obter a session activa
Session *session = GetSession(token);
if (session && session->sessionExpire >= currTime)
{
if (session->cliente->flags == ACCESS_LEVEL_ADMIN)
{
msg_put_short(ERROR_CODE_TIPO_CONTA_INVALIDA, s);
}
else
{
msg_put_short(ERROR_CODE_SUCCESS, s);
msg_put_int(0, s); //total de contas
int total = 0;
for (LinkedListNode * p = Begin(dbContas); p != NULL; p = Next(p))
{
Conta * conta = p->element;
if (conta->clientID == session->cliente->id)
{
msg_put_int(conta->contaID, s);
total += 1;
}
}
msg_put_int_at(5, total, s);
}
}
else
{
msg_put_short(ERROR_CODE_SESSAO_EXPIROU, s);
}
finalizePacket(s);
sendData(socket, s);
free(s);
}
void msg_consulta_saldo_integrada_handler(int socket, mensagem_s *msg)
{
if (msg->size < HEADER_SIZE + 4)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_CONSULTA_SALDO_INTEGRADA");
int token = msg_recv_int(msg);
mensagem_s * s = preparePacket(SMSG_CONSULTA_SALDO_INTEGRADA_RESPONSE);
//obter a session activa
Session *session = GetSession(token);
if (session && session->sessionExpire >= currTime)
{
if (session->cliente->flags == ACCESS_LEVEL_ADMIN)
{
msg_put_short(ERROR_CODE_TIPO_CONTA_INVALIDA, s);
}
else
{
msg_put_short(ERROR_CODE_SUCCESS, s);
int total = 0;
for (LinkedListNode * p = Begin(dbContas); p != NULL; p = Next(p))
{
Conta * conta = p->element;
if (conta->clientID == session->cliente->id)
{
total += conta->saldo;
}
}
msg_put_int(total, s);
}
}
else
{
msg_put_short(ERROR_CODE_SESSAO_EXPIROU, s);
}
finalizePacket(s);
sendData(socket, s);
free(s);
}
void msg_descongelar_conta_handler(int socket, mensagem_s *msg)
{
if (msg->size < HEADER_SIZE + 4 + 1)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_DESCONGELAR_CONTA");
int token = msg_recv_int(msg);
mensagem_s * s = preparePacket(SMSG_DESCONGELAR_CONTA_RESPONSE);
//obter a session activa
Session *session = GetSession(token);
if (session && session->sessionExpire >= currTime)
{
if (session->cliente->flags == ACCESS_LEVEL_ENTIDADE || session->cliente->flags == ACCESS_LEVEL_CLIENTE)
{
msg_put_short(ERROR_CODE_TIPO_CONTA_INVALIDA, s);
}
else
{
char *utilizador = msg_recv_string(msg);
Utilizador *cliente = GetCliente(utilizador);
if (cliente)
{
cliente->congelada = false;
DBWriteUtilizadores();
msg_put_short(ERROR_CODE_SUCCESS, s);
}
else
{
msg_put_short(ERROR_CODE_CONTA_INVALIDA, s);
}
free(utilizador);
}
}
else
{
msg_put_short(ERROR_CODE_SESSAO_EXPIROU, s);
}
finalizePacket(s);
sendData(socket, s);
free(s);
}
void msg_consultar_saldo_handler(int socket, mensagem_s *msg)
{
if (msg->size < HEADER_SIZE + 4 + 4)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_CONSULTAR_SALDO\n");
int token = msg_recv_int(msg);
mensagem_s * s = preparePacket(SMSG_CONSULTAR_SALDO_RESPONSE);
//obter a session activa
Session *session = GetSession(token);
if (session && session->sessionExpire >= currTime)
{
if (session->cliente->flags == ACCESS_LEVEL_ADMIN)
{
msg_put_short(ERROR_CODE_TIPO_CONTA_INVALIDA, s);
}
else
{
int contaId = msg_recv_int(msg);
Conta *conta = GetConta(contaId);
if (conta && conta->clientID == session->cliente->id)
{
msg_put_short(ERROR_CODE_SUCCESS, s);
msg_put_int(conta->saldo, s);
}
else
{
msg_put_short(ERROR_CODE_CONTA_INVALIDA, s);
}
}
}
else
{
msg_put_short(ERROR_CODE_SESSAO_EXPIROU, s);
}
finalizePacket(s);
sendData(socket, s);
free(s);
}
void WorldlinkMgr::loadWorldsFromDB(database::connection db) {
database::result result = database::query(db, "SELECT id,ipv4,port,name,link_key FROM servers", database::STORE_RESULT);
if (result) {
database::row row;
while (row = database::fetch_row(result)) {
//We do the conversion to integer only once and save it
DWORD id = database::toInt(row[0]);
//We create a new link structure
m_data[id] = new s_link;
//We fill the structure
m_data[id]->ipv4 = row[1];
m_data[id]->port = database::toInt(row[2]);
m_data[id]->name = row[3];
m_data[id]->link_key = row[4];
m_data[id]->online = false;
}
database::free_result(result);
}
preparePacket(); //generate packet for later use
}
void msg_valor_depositado_banco_handler(int socket, mensagem_s *msg)
{
if (msg->size < HEADER_SIZE + 4)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_VALOR_DEPOSITADO_BANCO");
int token = msg_recv_int(msg);
mensagem_s * s = preparePacket(SMSG_VALOR_DEPOSITADO_RESPONSE);
//obter a session activa
Session *session = GetSession(token);
if (session && session->sessionExpire >= currTime)
{
if (session->cliente->flags == ACCESS_LEVEL_ENTIDADE || session->cliente->flags == ACCESS_LEVEL_CLIENTE)
{
msg_put_short(ERROR_CODE_TIPO_CONTA_INVALIDA, s);
}
else
{
int total = 0;
for (LinkedListNode * p = Begin(dbContas); p != NULL; p = Next(p))
{
Conta * conta = p->element;
total += conta->saldo;
}
msg_put_short(ERROR_CODE_SUCCESS, s);
msg_put_int(total, s);
}
}
else
{
msg_put_short(ERROR_CODE_SESSAO_EXPIROU, s);
}
finalizePacket(s);
sendData(socket, s);
free(s);
}
bool PacketsManager::sendPacket(QString packet, QString& error)
{
bool valid_packet = preparePacket(packet,error);
if(valid_packet)
{
randomizePacket(packet);
bool valid_hex; //needed to QString::toUInt, see bellow
std::vector<BYTE> vData; //Vector to store packet data
QStringList packet_bytes = packet.split(" "); //List of tokens on packet string, we can use this cause of prepare packet
for each(QString s in packet_bytes) //loop the list & convert it to bytes, then store them on vector
vData.push_back(static_cast<BYTE>(s.toUInt(&valid_hex,16)));
if(!SendPacket(vData)) //send the packet
{
valid_packet = false;
error = "Error sending the packet.";
}
}
return valid_packet;
}
void msg_movimento_entre_contas_handler(int socket, mensagem_s *msg)
{
if (msg->size < HEADER_SIZE + 4 + 4 + 4 + 4)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_MOVIMENTO_ENTRE_CONTAS\n");
int token = msg_recv_int(msg);
mensagem_s * s = preparePacket(SMSG_MOVIMENTO_ENTRE_CONTAS_RESPONSE);
//obter a session activa
Session *session = GetSession(token);
if (session && session->sessionExpire >= currTime)
{
if (session->cliente->flags == ACCESS_LEVEL_ADMIN)
{
msg_put_short(ERROR_CODE_TIPO_CONTA_INVALIDA, s);
}
else
{
int montante = msg_recv_int(msg);
int contaOrigem = msg_recv_int(msg);
int contaDestino = msg_recv_int(msg);
Conta *contaO = GetConta(contaOrigem);
Conta *contaD = GetConta(contaDestino);
if (contaO && contaO->clientID == session->cliente->id && contaD && contaD->clientID == session->cliente->id)
{
if (contaO->saldo < montante)
{
msg_put_short(ERROR_CODE_SALDO_INSUFICIENTE, s);
}
else
{
contaO->saldo -= montante;
contaD->saldo += montante;
//criar movimentos de conta
//origem
Movimento *movimentoO = malloc(sizeof(Movimento));
movimentoO->owner = contaO->contaID;
movimentoO->contaO = contaO->contaID;
movimentoO->ContaD = contaD->contaID;
movimentoO->id = genMovimentoID();
movimentoO->Montante = montante;
movimentoO->tipo = TIPO_MOVIMENTO_DEBITO;
MovimentoAdd(movimentoO);
//destino
Movimento *movimentoD = malloc(sizeof(Movimento));
movimentoD->owner = contaD->contaID;
movimentoD->contaO = contaO->contaID;
movimentoD->ContaD = contaD->contaID;
movimentoD->id = genMovimentoID();
movimentoD->Montante = montante;
movimentoD->tipo = TIPO_MOVIMENTO_CREDITO;
MovimentoAdd(movimentoD);
//actualizar a db
DBWriteContas();
msg_put_short(ERROR_CODE_SUCCESS, s);
}
}
else
{
msg_put_short(ERROR_CODE_CONTA_INVALIDA, s);
}
}
}
else
{
msg_put_short(ERROR_CODE_SESSAO_EXPIROU, s);
}
finalizePacket(s);
sendData(socket, s);
free(s);
}
void msg_efectuar_pagamento_servico_handler(int socket, mensagem_s * msg)
{
if (msg->size < HEADER_SIZE + 4 + 4 + 4 + 4)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_EFECTUAR_PAGAMENTO_SERVICO\n");
int token = msg_recv_int(msg);
mensagem_s * s = preparePacket(SMSG_EFECTUAR_PAGAMENTO_SERVICO_RESPONSE);
//obter a session activa
Session *session = GetSession(token);
if (session && session->sessionExpire >= currTime)
{
if (session->cliente->flags == ACCESS_LEVEL_ADMIN || session->cliente->flags == ACCESS_LEVEL_ENTIDADE)
{
msg_put_short(ERROR_CODE_TIPO_CONTA_INVALIDA, s);
}
else
{
int servicoId = msg_recv_int(msg);
int contaOrigem = msg_recv_int(msg);
int montante = msg_recv_int(msg);
Conta *conta = GetConta(contaOrigem);
if (conta)
{
if (conta->saldo < montante)
{
msg_put_short(ERROR_CODE_SALDO_INSUFICIENTE, s);
}
else
{
Servico *servico = GetServico(servicoId);
if (servico)
{
//obter a conta de destino para onde vai ser depositado o dinheiro
Conta *contaD = GetConta(servico->nib);
if (contaD)
{
contaD->saldo += montante;
conta->saldo -= montante;
Movimento *movimentoO = malloc(sizeof(Movimento));
movimentoO->owner = conta->contaID;
movimentoO->contaO = conta->contaID;
movimentoO->ContaD = contaD->contaID;
movimentoO->id = genMovimentoID();
movimentoO->Montante = montante;
movimentoO->tipo = TIPO_MOVIMENTO_DEBITO;
MovimentoAdd(movimentoO);
Movimento *movimentoD = malloc(sizeof(Movimento));
movimentoD->owner = contaD->contaID;
movimentoD->contaO = conta->contaID;
movimentoD->ContaD = contaD->contaID;
movimentoD->id = genMovimentoID();
movimentoD->Montante = montante;
movimentoD->tipo = TIPO_MOVIMENTO_CREDITO;
MovimentoAdd(movimentoD);
DBWriteContas();
msg_put_short(ERROR_CODE_SUCCESS, s);
}
else
{
msg_put_short(ERROR_CODE_GERAL, s);
}
}
else
{
msg_put_short(ERROR_CODE_SERVICO_NAO_EXISTE, s);
}
}
}
else
{
msg_put_short(ERROR_CODE_CONTA_INVALIDA, s);
}
}
}
else
{
msg_put_short(ERROR_CODE_SESSAO_EXPIROU, s);
}
finalizePacket(s);
sendData(socket, s);
free(s);
}
AREXPORT bool ArDPPTU::init(void)
{
preparePacket();
myPacket.byteToBuf(ArDPPTUCommands::INIT);
if (!sendPacket(&myPacket))
{
ArLog::log(ArLog::Terse, "ArDPPTU: Error sending INIT to PTU! (Write error?)");
return false;
}
myPan = -1; //myPan and myTilt set to -1 for initial positioning
myTilt = -1;
setMovePower(PAN, LOW);
setMovePower(TILT, LOW);
setHoldPower(PAN, OFF);
setHoldPower(PAN, OFF);
switch(myDeviceType) {
case PANTILT_PTUD47:
//Assuming default accel and slew rates
myPanSlew = 40;
myBasePanSlew = 40;
myTiltSlew = 40;
myBaseTiltSlew = 40;
myPanAccel = 80;
myTiltAccel = 80;
break;
case PANTILT_PTUD46:
case PANTILT_DEFAULT:
default:
//Assuming default accel and slew rates
myPanSlew = 40; // 1000 positions/sec
myBasePanSlew = 40; // 1000 positions/sec
myTiltSlew = 40; // 1000 positions/sec
myBaseTiltSlew = 40; // 1000 positions/sec
myPanAccel = 80; // 2000 positions/sec^2
myTiltAccel = 80; // 2000 positions/sec^2
break;
}
if(myDeviceType == PANTILT_DEFAULT)
{
// query resolution, conversion factors will be
// set again based on responses (replacing default value set
// in constructor)
preparePacket();
myPacket.byteToBuf('P');
myPacket.byteToBuf('R');
if(!sendPacket(&myPacket))
ArLog::log(ArLog::Terse, "ArDPPTU: Warning: write error sending pan resolution query");
// We can't distinguish PR and TR responses based on their content alone, so
// we have to query pan resolution (PR), then after receiving resolution
// response, query TR. (see readPacket() for TR).
///@todo query the device for pan and tilt limits, and when response is received, call ArPTZ::setLimits() to change.
}
query(); // do first position query
if (!panTilt(0,0))
return false;
myInit = true;
return true;
}
void WorldlinkMgr::destroyLink(DWORD id) {
m_data[id]->online = false;
preparePacket(); //regenerate packet for later use
}
void WorldlinkMgr::createLink(DWORD id) {
m_data[id]->online = true;
preparePacket(); //regenerate packet for later use
}
void msg_apagar_conta_handler(int socket, mensagem_s *msg)
{
if (msg->size < HEADER_SIZE + 4 + 4 + 4)
{
disconnect(socket);
return;
}
fprintf(stdout, "MENSAGEM: CMSG_APAGAR_CONTA\n");
int token = msg_recv_int(msg);
mensagem_s * s = preparePacket(SMSG_APAGAR_CONTA_RESPONSE);
//obter a session activa
Session *session = GetSession(token);
if (session && session->sessionExpire >= currTime)
{
if (session->cliente->flags == ACCESS_LEVEL_ADMIN)
{
msg_put_short(ERROR_CODE_TIPO_CONTA_INVALIDA, s);
}
else
{
int contaOrigem = msg_recv_int(msg);
int contaDestino = msg_recv_int(msg);
Conta *contaO = GetConta(contaOrigem);
Conta *contaD = GetConta(contaDestino);
if (contaO && contaO->clientID == session->cliente->id && contaD && contaD->clientID == session->cliente->id)
{
contaD->saldo += contaO->saldo;
//criar o movimento
Movimento *movimentoO = malloc(sizeof(Movimento));
movimentoO->owner = contaD->contaID;
movimentoO->contaO = contaO->contaID;
movimentoO->ContaD = contaD->contaID;
movimentoO->id = genMovimentoID();
movimentoO->Montante = contaO->saldo;
movimentoO->tipo = TIPO_MOVIMENTO_CREDITO;
MovimentoAdd(movimentoO);
contaO->saldo = 0;
//remover todos os movimentos associados a esta conta
for (LinkedListNode * p = Begin(dbMovimentos); p != NULL;)
{
Movimento * movimento = p->element;
if (movimento->owner == contaO->contaID)
{
p = Next(p);
list_remove(movimento, dbMovimentos);
}
else
{
p = Next(p);
}
}
DBWriteMovimentos();
//remover a conta
list_remove(contaO, dbContas);
DBWriteContas();
msg_put_short(ERROR_CODE_SUCCESS, s);
}
else
{
msg_put_short(ERROR_CODE_CONTA_INVALIDA, s);
}
}
}
else
{
msg_put_short(ERROR_CODE_SESSAO_EXPIROU, s);
}
finalizePacket(s);
sendData(socket, s);
free(s);
}
void WorldlinkMgr::reloadWorldsFromDB(database::connection db) {
clearWorlds();
loadWorldsFromDB(db);
preparePacket(); //regenerate packet for later use
}
int handleSocketBroadcast(unsigned char *data, int data_len, struct sockaddr_in *sa_client,
socklen_t sa_client_len, struct sockaddr_in *sa_recv)
{
struct sockaddr_in sa_send;
socklen_t sa_send_len = sizeof(struct sockaddr_in);
int send_sock, sent = 0, offset = 0;
DPlayPacket lobby_info = {0, DPLAY_ID, NULL, ACTION_STRING, 0,0,0,NULL};
unsigned char lobby_info_body[512], temp[1024];
unsigned char backslash[] = { '\\', '\0', '\0', '\0'};
unsigned char game_name[] = { 't', '\0', 'e', '\0', 's', '\0', 't', '\0',
'g', '\0', 'a', '\0', 'm', '\0', 'e', '\0', '\0', '\0'};
unsigned char dpid[] = { 0x00, 0x54, 0x32, 0x10};
unsigned char magic_number[] = {0x44, 0x00, 0x00, 0x00};
unsigned char lobby_info_size[] = {0x50, 0x00, 0x00, 0x00};
unsigned char magic_16_bytes[] = { 0x0a, 0, 0, 0, 0x04, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
unsigned char unknown[] = { 0x0a, 0, 0, 0, 0x0f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
memset(&sa_send, 0, sa_send_len);
lobby_info.type = LOBBY_INFORMATION;
lobby_info.version = DPLAY7;
lobby_info.sa = sa_recv;
lobby_info.data_size = 80 + sizeof(backslash) + sizeof(game_name);
lobby_info.data = lobby_info_body;
lobby_info.size = sizeNeeded(&lobby_info);
memcpy(lobby_info_body + offset, lobby_info_size, 4); offset += 4;
memcpy(lobby_info_body + offset, magic_number, 4); offset += 4;
memcpy(lobby_info_body + offset, fake_guid, 16); offset += 16;
memcpy(lobby_info_body + offset, chatconnect_guid, 16); offset += 16;
memcpy(lobby_info_body + offset, magic_16_bytes, 16); offset += 16;
memcpy(lobby_info_body + offset, dpid, 4); offset += 4;
memcpy(lobby_info_body + offset, unknown, 20); offset += 20;
memcpy(lobby_info_body + offset, backslash, sizeof(backslash)); offset += sizeof(backslash);
memcpy(lobby_info_body + offset, game_name, sizeof(game_name)); offset += sizeof(game_name);
memcpy(&sa_send, data+4, 16);
sa_send.sin_addr = sa_client->sin_addr;
preparePacket(temp, &lobby_info);
printf("Sending Lobby Information packet to %s:%d\n", inet_ntoa(sa_send.sin_addr),
ntohs(sa_send.sin_port));
if((send_sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) < 0)
{
perror("socket");
return 1;
}
if(connect(send_sock, (struct sockaddr *)&sa_send, sa_send_len) < 0)
{
perror("connect");
return 9;
}
while(sent < lobby_info.size)
{
sent = send(send_sock, temp+sent, lobby_info.size - sent, 0);
if(sent < 0)
{
perror("sent");
return 10;
}
}
return 0;
}