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