static void test_group(CuTest * tc)
{
unit *u;
region *r;
faction *f;
group *g;
test_cleanup();
test_create_world();
r = findregion(0, 0);
f = test_create_faction(0);
assert(r && f);
u = test_create_unit(f, r);
assert(u);
CuAssertTrue(tc, join_group(u, "hodor"));
CuAssertPtrNotNull(tc, (g = get_group(u)));
CuAssertStrEquals(tc, "hodor", g->name);
CuAssertIntEquals(tc, 1, g->members);
set_group(u, 0);
CuAssertIntEquals(tc, 0, g->members);
CuAssertPtrEquals(tc, 0, get_group(u));
set_group(u, g);
CuAssertIntEquals(tc, 1, g->members);
CuAssertPtrEquals(tc, g, get_group(u));
test_cleanup();
}
static void test_give_unit(CuTest * tc) {
struct give env = { 0 };
test_setup_ex(tc);
env.f1 = test_create_faction(NULL);
env.f2 = test_create_faction(NULL);
setup_give(&env);
CuAssertIntEquals(tc, 1, env.f1->num_units);
CuAssertIntEquals(tc, 1, env.f2->num_units);
join_group(env.src, "group");
config_set("rules.give.max_men", "0");
give_unit(env.src, env.dst, NULL);
CuAssertPtrEquals(tc, env.f1, env.src->faction);
CuAssertIntEquals(tc, 0, env.f2->newbies);
config_set("rules.give.max_men", "-1");
give_unit(env.src, env.dst, NULL);
CuAssertPtrEquals(tc, env.f2, env.src->faction);
CuAssertPtrEquals(tc, NULL, get_group(env.src));
CuAssertIntEquals(tc, 1, env.f2->newbies);
CuAssertPtrEquals(tc, NULL, env.f1->units);
CuAssertPtrNotNull(tc, test_find_messagetype(env.f1->msgs, "give_person"));
CuAssertPtrNotNull(tc, test_find_messagetype(env.f2->msgs, "receive_person"));
test_teardown();
}
void ClientHandler::procesar_peticion(mensajes::mensajes_local_broker_t & mensaje) {
switch (mensaje.peticion) {
case mensajes::REGISTER:
//Log::debug("Register %s", mensaje.datos);
//std::cout << "Register: " << mensaje.datos << std::endl;
nombre_cliente.assign(mensaje.datos);
break;
case mensajes::JOIN:
case mensajes::JOIN_FORK:
//std::cout << "Join: " << mensaje.datos << std::endl;
// buscar el grupo en el que está el recurso, si no existe crearlo
join_group(mensaje.datos);
tipo_join = mensaje.peticion;
#ifdef __x86_64__
snprintf(mensaje.datos, DATA_SIZE, "%lu:%lu", this->cantidad_de_bloques_a_enviar, this->tamanio_memoria);
#else
snprintf(mensaje.datos, DATA_SIZE, "%u:%u",
this->cantidad_de_bloques_a_enviar, this->tamanio_memoria);
#endif
mensaje.respuesta = mensajes::OK;
break;
case mensajes::LEAVE:
//std::cout << "Leave: " << mensaje.datos << std::endl;
// sacar al cliente del grupo
mensaje.respuesta = mensajes::OK;
break;
default:
break;
}
socket.sendsome(&mensaje, sizeof(mensajes::mensajes_local_broker_t));
}
void gcomm::AsioUdpSocket::connect(const gu::URI& uri)
{
gcomm_assert(state() == S_CLOSED);
Critical<AsioProtonet> crit(net_);
asio::ip::udp::resolver resolver(net_.io_service_);
asio::ip::udp::resolver::query query(unescape_addr(uri.get_host()),
uri.get_port());
asio::ip::udp::resolver::iterator conn_i(resolver.resolve(query));
target_ep_ = conn_i->endpoint();
socket_.open(conn_i->endpoint().protocol());
socket_.set_option(asio::ip::udp::socket::reuse_address(true));
socket_.set_option(asio::ip::udp::socket::linger(true, 1));
set_fd_options(socket_);
asio::ip::udp::socket::non_blocking_io cmd(true);
socket_.io_control(cmd);
const std::string if_addr(
unescape_addr(
uri.get_option("socket.if_addr",
anyaddr(conn_i->endpoint().address()))));
asio::ip::address local_if(asio::ip::address::from_string(if_addr));
if (is_multicast(conn_i->endpoint()) == true)
{
join_group(socket_, conn_i->endpoint(), local_if);
socket_.set_option(
asio::ip::multicast::enable_loopback(
gu::from_string<bool>(uri.get_option("socket.if_loop", "false"))));
socket_.set_option(
asio::ip::multicast::hops(
gu::from_string<int>(uri.get_option("socket.mcast_ttl", "1"))));
socket_.bind(*conn_i);
}
else
{
socket_.bind(
asio::ip::udp::endpoint(
local_if,
gu::from_string<unsigned short>(uri.get_port())));
}
async_receive();
state_ = S_CONNECTED;
}
static void test_group_readwrite_dead_faction(CuTest *tc) {
gamedata data;
storage store;
faction *f, *f2;
unit * u;
group *g;
ally *al;
int fno;
test_cleanup();
f = test_create_faction(0);
fno = f->no;
CuAssertPtrEquals(tc, f, factions);
CuAssertPtrEquals(tc, 0, f->next);
f2 = test_create_faction(0);
CuAssertPtrEquals(tc, f2, factions->next);
u = test_create_unit(f2, test_create_region(0, 0, 0));
CuAssertPtrNotNull(tc, u);
g = join_group(u, "group");
CuAssertPtrNotNull(tc, g);
al = ally_add(&g->allies, f);
CuAssertPtrNotNull(tc, al);
CuAssertPtrEquals(tc, f, factions);
destroyfaction(&factions);
CuAssertTrue(tc, !f->_alive);
CuAssertPtrEquals(tc, f2, factions);
mstream_init(&data.strm);
gamedata_init(&data, &store, RELEASE_VERSION);
write_game(&data);
free_gamedata();
f = f2 = NULL;
data.strm.api->rewind(data.strm.handle);
read_game(&data);
mstream_done(&data.strm);
gamedata_done(&data);
CuAssertPtrEquals(tc, 0, findfaction(fno));
f2 = factions;
CuAssertPtrNotNull(tc, f2);
u = f2->units;
CuAssertPtrNotNull(tc, u);
g = get_group(u);
CuAssertPtrNotNull(tc, g);
CuAssertPtrEquals(tc, 0, g->allies);
test_cleanup();
}
void u_setfaction(unit * u, faction * f)
{
int cnt = u->number;
if (u->faction == f)
return;
if (u->faction) {
set_number(u, 0);
if (count_unit(u))
--u->faction->no_units;
join_group(u, NULL);
free_orders(&u->orders);
set_order(&u->thisorder, NULL);
if (u->nextF)
u->nextF->prevF = u->prevF;
if (u->prevF)
u->prevF->nextF = u->nextF;
else
u->faction->units = u->nextF;
}
if (f != NULL) {
if (f->units)
f->units->prevF = u;
u->prevF = NULL;
u->nextF = f->units;
f->units = u;
} else
u->nextF = NULL;
u->faction = f;
if (u->region)
update_interval(f, u->region);
if (cnt && f) {
set_number(u, cnt);
if (count_unit(u))
++f->no_units;
}
}
/* Group Handlers */
struct group_data * create_group(struct char_data * leader)
{
struct group_data * new_group;
/* Allocate Group Memory & Attach to Group List*/
CREATE(new_group, struct group_data, 1);
add_to_list(new_group, group_list);
/* Allocate Members List */
new_group->members = create_list();
/* Clear Data */
new_group->group_flags = 0;
/* Assign Data */
SET_BIT(GROUP_FLAGS(new_group), GROUP_OPEN);
if (IS_NPC(leader))
SET_BIT(GROUP_FLAGS(new_group), GROUP_NPC);
join_group(leader, new_group);
return (new_group);
}
static void join(const char *ifname, const char *mcast, const char* group, const char *addr, const char *port_str) {
int ifindex;
struct in_addr iface_addr;
struct in_addr group_addr;
struct in_addr bind_addr;
int port;
int result;
int fd;
struct sockaddr_in sock_addr;
ifindex = name_to_index(ifname);
if (ifindex < 0) {
fprintf(stderr, "%s: could not find interface: %s\n",
prog_name, ifname);
exit(1);
}
result = inet_pton(AF_INET, mcast, &iface_addr);
if (result <= 0) {
fprintf(stderr, "%s: bad interface address: %s\n",
prog_name, mcast);
exit(1);
}
result = inet_pton(AF_INET, group, &group_addr);
if (result <= 0) {
fprintf(stderr, "%s: bad group address: %s\n",
prog_name, group);
exit(1);
}
result = inet_pton(AF_INET, addr, &bind_addr);
if (result <= 0) {
fprintf(stderr, "%s: bad bind address: %s\n",
prog_name, addr);
exit(1);
}
port = atoi(port_str);
fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (fd < 0) {
fprintf(stderr,
"%s: could not create socket: socket(): errno=%d: %s\n",
prog_name, errno, strerror(errno));
exit(1);
}
{
int enable = 1; /* boolean */
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *) &enable, sizeof enable)) {
fprintf(stderr,
"%s: could not set SO_REUSEADDR: errno=%d: %s\n",
prog_name, errno, strerror(errno));
}
}
{
/* will request IP_PKTINFO info while reading the socket */
int opt = 1;
if (setsockopt(fd, SOL_IP, IP_PKTINFO, &opt, sizeof opt)) {
fprintf(stderr, "%s: could not set IP_PKTINFO: errno=%d: %s\n",
prog_name, errno, strerror(errno));
}
}
if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, (void *) &iface_addr, sizeof iface_addr)) {
fprintf(stderr, "%s: could not multicast interface: errno=%d: %s\n",
prog_name, errno, strerror(errno));
}
if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, ifname, strlen(ifname))) {
fprintf(stderr, "%s: could set SO_BINDTODEVICE: errno=%d: %s\n",
prog_name, errno, strerror(errno));
}
sock_addr.sin_family = AF_INET;
sock_addr.sin_addr = bind_addr;
sock_addr.sin_port = htons(port);
if (bind(fd, (struct sockaddr *)&sock_addr, sizeof(sock_addr))) {
fprintf(stderr,
"%s: could not bind socket: errno=%d: %s\n",
prog_name, errno, strerror(errno));
exit(1);
}
if (join_group(fd, ifindex, group_addr)) {
fprintf(stderr,
"%s: could not join group: errno=%d: %s\n",
prog_name, errno, strerror(errno));
exit(1);
}
printf("%s: joined, reading...\n", prog_name);
read_loop(fd);
close(fd);
}
/*解析消息线程*/
void *pthread_func()
{
int group_fd; //组播套接字
group_fd = udp_link();
head_user = (struct user_info *)malloc(sizeof(struct user_info));
head_user->next = NULL;
struct user_info *tmp; // 循环变量，用于便利在线用户链表将其发送给第一次登录的或者有刷新请求的客户端
struct servmsg *free_tmp;
int ret= -1;
while(1){
while(H->next != NULL){
free_tmp = H;
H = H->next; //消息头，处理玩就往后移动
free(free_tmp);//将处理完的消息所占内存释放掉
free_tmp = NULL;
printf("消息来自:%s IP:PORT:%s:%d\n",H->recvmsg.self_name,inet_ntoa(H->addr.sin_addr),ntohs(H->addr.sin_port));
switch(H->recvmsg.type)
{
case LOG_IN:
printf("%s登录消息\n",H->recvmsg.self_name);
send_message_to_all(H,LOGIN_TOALL);
add_user(head_user,H);
break;
case REFRESH:
printf("%s刷新消息\n",H->recvmsg.self_name);
//usleep(50000);
send_all_online(H->addr);
break;
case CHAT_PRI:
printf("%s私聊消息\n",H->recvmsg.self_name);
printf("目标：%s\n",H->recvmsg.dst_name);
chat_private();
break;
case CHAT_ALL:
printf("%s群聊消息\n",H->recvmsg.self_name);
send_message_to_all(H,CHAT_ALL);
break;
case FILE_NAME:
printf("%s申请下载\n",H->recvmsg.self_name);
send_dir_allfile(H->addr);
break;
case DOWNLOAD:
printf("%s 确认下载\n",H->recvmsg.self_name);
pthread_create(&tid2,NULL,download_send,(void *)&H->addr);
pthread_detach(tid2);
break;
case UPLOAD:
printf("%s上传文件\n",H->recvmsg.self_name);
pthread_create(&tid3,NULL,(void *)&upload_func,NULL);
pthread_detach(tid3);
break;
case OFFLINE:
printf("%s下线\n",H->recvmsg.self_name);
delete_user(H->recvmsg.self_name);
break;
case CREATE_GROUP:
printf("%s create group\n",H->recvmsg.self_name);
create_group(H);
break;
case JOIN_GROUP:
printf("%s join group\n",H->recvmsg.self_name);
join_group(H);
break;
case LIST_GROUP:
printf("%s list group\n",H->recvmsg.self_name);
list_group(H);
break;
case GROUP_CHAT:
printf("%s group chat\n",H->recvmsg.self_name);
group_chat(H);
break;
case GROUP_DELETE:
printf("%s delete group\n",H->recvmsg.self_name);
delete_group(H);
break;
default:
printf("msg type error !\n");
break;
}
printf("-----------------------------------\n");
}
}
}
int
main(int argc, char **argv)
{
int i, opt, rc;
int sock;
struct timeval now;
gettime(&now);
inet_pton(AF_INET6, "ff02::1:6", &babel_group);
babel_port = 6696;
srand(now.tv_sec ^ now.tv_usec);
while(1) {
opt = getopt(argc, argv, "p:u:h:c:");
if(opt < 0)
break;
switch(opt) {
case 'p': /* prefix */
if(have_prefix)
goto usage;
rc = inet_pton(AF_INET6, optarg, &myprefix);
if(rc != 1)
goto usage;
have_prefix = 1;
break;
case 'u': /* update interval */
update_interval = atoi(optarg);
if(update_interval <= 0)
goto usage;
break;
case 'h': /* hello interval */
hello_interval = atoi(optarg);
if(hello_interval <= 0)
goto usage;
break;
case 'c': /* link cost */
link_cost = atoi(optarg);
if(link_cost <= 0)
goto usage;
break;
default:
goto usage;
}
}
if(!have_prefix)
fprintf(stderr, "Warning: you didn't ask me to announce a prefix.\n");
if(argc - optind > MAXINTERFACES) {
fprintf(stderr, "Too many interfaces.\n");
exit(1);
}
for(i = 0; i < argc - optind; i++) {
int index;
index = if_nametoindex(argv[optind + i]);
if(index <= 0) {
fprintf(stderr, "Unknown interface %s\n", argv[i]);
exit(1);
}
memset(&interfaces[i], 0, sizeof(interfaces[i]));
interfaces[i].ifindex = index;
interfaces[i].ifname = argv[optind + i];
rc = get_local_address(interfaces[i].ifindex, &interfaces[i].address);
if(rc < 0) {
perror("get_local_address");
fprintf(stderr, "Continuing anyway -- "
"won't perform reachibility detection "
"on interface %s.\n", interfaces[i].ifname);
}
interfaces[i].seqno = rand() & 0xFFFF;
}
numinterfaces = argc - optind;
random_eui64(my_router_id);
myseqno = rand() & 0xFFFF;
sock = babel_socket(babel_port);
if(sock < 0) {
perror("babel_socket");
exit(1);
}
for(i = 0; i < numinterfaces; i++) {
rc = join_group(sock, interfaces[i].ifindex, &babel_group);
if(rc < 0) {
perror("setsockopt(IPV6_JOIN_GROUP)");
exit(1);
}
}
catch_signals(sigexit);
while(!exiting) {
struct sockaddr_in6 sin6;
unsigned char buf[BUF_SIZE];
struct timeval tv, update, zerotv = {0, 0};
fd_set readfds;
int hello_count = 0;
/* Compute when to wake up. */
gettime(&now);
timeval_add_msec(&tv, &last_hello, hello_interval * 700 + rand() % 300);
timeval_add_msec(&update, &last_update,
update_interval * 700 + rand() % 300);
timeval_min(&tv, &update);
if(selected_nexthop_metric < INFINITY) {
int n = find_neighbour(selected_interface, &selected_nexthop, 0);
assert(n >= 0);
timeval_min(&tv, &neighbours[n].timeout);
timeval_min(&tv, &selected_nexthop_timeout);
}
if(timeval_compare(&tv, &now) > 0)
timeval_minus(&tv, &tv, &now);
else
tv = zerotv;
FD_ZERO(&readfds);
FD_SET(sock, &readfds);
rc = select(sock + 1, &readfds, NULL, NULL, &tv);
if(rc < 0 && errno != EINTR) {
perror("select");
nap(1000);
continue;
}
if(rc > 0) {
/* Oh good, a packet. */
socklen_t sin6len = sizeof(sin6);
rc = recvfrom(sock, buf, BUF_SIZE, 0,
(struct sockaddr*)&sin6, &sin6len);
if(rc < 0 || rc >= BUF_SIZE) {
if(rc < 0 && errno != EAGAIN) {
perror("recv");
nap(100);
}
continue;
}
if(sin6.sin6_family != PF_INET6) {
fprintf(stderr, "Received unexpected packet in family %d.\n",
sin6.sin6_family);
nap(100);
continue;
}
i = find_interface(sin6.sin6_scope_id);
if(i < 0) {
fprintf(stderr, "Received packet on unknown interface %d.\n",
sin6.sin6_scope_id);
nap(100);
continue;
}
handle_packet(sock, buf, rc, &interfaces[i], &sin6.sin6_addr);
}
gettime(&now);
if(selected_nexthop_metric < INFINITY) {
int n = find_neighbour(selected_interface, &selected_nexthop, 0);
assert(n >= 0);
if(neighbour_expired(n, &now)) {
/* Expire neighbour. */
flush_default_route();
delete_neighbour(n);
} else if(timeval_compare(&now, &selected_nexthop_timeout) > 0) {
/* Expire route. */
flush_default_route();
}
/* Send a request? */
}
/* Is it time to send hellos? */
if(timeval_minus_msec(&now, &last_hello) > hello_interval * 700) {
for(i = 0; i < numinterfaces; i++)
send_hello(sock, &interfaces[i]);
last_hello = now;
hello_count++;
/* Make an expiry pass every ten hellos. */
if(hello_count >= 10) {
expire_neighbours();
hello_count = 0;
}
}
/* Is it time to send an update? */
if(timeval_minus_msec(&now, &last_update) > update_interval * 700) {
for(i = 0; i < numinterfaces; i++)
send_update(sock, &interfaces[i], 0);
last_update = now;
}
}
/* Send a bunch of retractions. */
for(i = 0; i < numinterfaces; i++)
send_update(sock, &interfaces[i], 1);
flush_default_route();
return 0;
usage:
fprintf(stderr,
"Usage: sbabeld "
"[-p prefix] [-u interval] [-h interval] [-c cost] interface...\n");
return 1;
}
