/**************************************************************************** send out one query ****************************************************************************/ static BOOL query_one(char *lookup, unsigned int lookup_type) { int j, count, flags; struct in_addr *ip_list=NULL; if (got_bcast) { printf("querying %s on %s\n", lookup, inet_ntoa(bcast_addr)); ip_list = name_query(ServerFD,lookup,lookup_type,use_bcast, use_bcast?True:recursion_desired, bcast_addr,&count, &flags); } else { struct in_addr *bcast; for (j=iface_count() - 1; !ip_list && j >= 0; j--) { bcast = iface_n_bcast(j); printf("querying %s on %s\n", lookup, inet_ntoa(*bcast)); ip_list = name_query(ServerFD,lookup,lookup_type, use_bcast, use_bcast?True:recursion_desired, *bcast,&count, &flags); } } if (give_flags) printf("Flags: %s\n", query_flags(flags)); if (!ip_list) return False; for (j=0;j<count;j++) { if (translate_addresses) { struct hostent *host = gethostbyaddr((char *)&ip_list[j], sizeof(ip_list[j]), AF_INET); if (host) { printf("%s, ", host -> h_name); } } printf("%s %s<%02x>\n",inet_ntoa(ip_list[j]),lookup, lookup_type); } /* We can only do find_status if the ip address returned was valid - ie. name_query returned true. */ if (find_status) { do_node_status(ServerFD, lookup, lookup_type, ip_list[0]); } safe_free(ip_list); return (ip_list != NULL); }
static bool query_one(const char *lookup, unsigned int lookup_type) { int j, count; uint8_t flags; struct sockaddr_storage *ip_list=NULL; NTSTATUS status = NT_STATUS_NOT_FOUND; if (got_bcast) { char addr[INET6_ADDRSTRLEN]; print_sockaddr(addr, sizeof(addr), &bcast_addr); d_printf("querying %s on %s\n", lookup, addr); status = name_query(lookup,lookup_type,use_bcast, use_bcast?true:recursion_desired, &bcast_addr, talloc_tos(), &ip_list, &count, &flags); } else { status = name_resolve_bcast( lookup, lookup_type, talloc_tos(), &ip_list, &count); } if (!NT_STATUS_IS_OK(status)) { return false; } if (give_flags) { d_printf("Flags: %s\n", query_flags(flags)); } for (j=0;j<count;j++) { char addr[INET6_ADDRSTRLEN]; if (translate_addresses) { char h_name[MAX_DNS_NAME_LENGTH]; h_name[0] = '\0'; if (sys_getnameinfo((const struct sockaddr *)&ip_list[j], sizeof(struct sockaddr_storage), h_name, sizeof(h_name), NULL, 0, NI_NAMEREQD)) { continue; } d_printf("%s, ", h_name); } print_sockaddr(addr, sizeof(addr), &ip_list[j]); d_printf("%s %s<%02x>\n", addr,lookup, lookup_type); /* We can only do find_status if the ip address returned was valid - ie. name_query returned true. */ if (find_status) { if (!do_node_status(lookup, lookup_type, &ip_list[j])) { status = NT_STATUS_UNSUCCESSFUL; } } } TALLOC_FREE(ip_list); return NT_STATUS_IS_OK(status); }
static struct in_addr *lookup_byname_backend(const char *name, int *count) { int fd; struct in_addr *ret = NULL; struct in_addr p; int j, flags; *count = 0; fd = wins_lookup_open_socket_in(); if (fd == -1) return NULL; p = wins_srv_ip(); if( !is_zero_ip(p) ) { ret = name_query(fd,name,0x20,False,True, p, count, &flags); goto out; } if (lp_wins_support()) { /* we are our own WINS server */ ret = name_query(fd,name,0x20,False,True, *interpret_addr2("127.0.0.1"), count, &flags); goto out; } /* uggh, we have to broadcast to each interface in turn */ for (j=iface_count() - 1; j >= 0; j--) { struct in_addr *bcast = iface_n_bcast(j); ret = name_query(fd,name,0x20,True,True,*bcast,count, &flags); if (ret) break; } out: close(fd); return ret; }
/******************************************************** resolve via "wins" method *********************************************************/ static BOOL resolve_wins (const char *name, struct in_addr *return_ip, int name_type) { int sock; struct in_addr wins_ip; BOOL wins_ismyip; /* * "wins" means do a unicast lookup to the WINS server. * Ignore if there is no WINS server specified or if the * WINS server is one of our interfaces (if we're being * called from within nmbd - we can't do this call as we * would then block). */ DEBUG (3, ("resolve_name: Attempting wins lookup for name %s<0x%x>\n", name, name_type)); if (!*lp_wins_server ()) { DEBUG (3, ("resolve_name: WINS server resolution selected and no WINS server present.\n")); return False; } wins_ip = *interpret_addr2 (lp_wins_server ()); wins_ismyip = ismyip (wins_ip); if ((wins_ismyip && !global_in_nmbd) || !wins_ismyip) { sock = open_socket_in (SOCK_DGRAM, 0, 3, interpret_addr (lp_socket_address ()), True); if (sock != -1) { struct in_addr *iplist = NULL; int count; iplist = name_query (sock, name, name_type, False, True, wins_ip, &count, NULL); if (iplist != NULL) { *return_ip = iplist[0]; free ((char *) iplist); close (sock); return True; } close (sock); } } return False; }
static struct sockaddr_storage *lookup_byname_backend(TALLOC_CTX *mem_ctx, const char *name, int *count) { struct ip_service *ret = NULL; struct sockaddr_storage *return_ss = NULL; int j, i; NTSTATUS status; *count = 0; /* always try with wins first */ if (NT_STATUS_IS_OK(resolve_wins(name,0x20,&ret,count))) { if ( *count == 0 ) return NULL; return_ss = TALLOC_ARRAY(mem_ctx, struct sockaddr_storage, *count); if (return_ss == NULL ) { free( ret ); return NULL; } /* copy the IP addresses */ for ( i=0; i<(*count); i++ ) return_ss[i] = ret[i].ss; free( ret ); return return_ss; } /* uggh, we have to broadcast to each interface in turn */ for (j=iface_count() - 1; j >= 0; j--) { const struct sockaddr_storage *bcast_ss = iface_n_bcast(j); if (!bcast_ss) { continue; } status = name_query(name, 0x20, True, True,bcast_ss, mem_ctx, &return_ss, count, NULL); if (NT_STATUS_IS_OK(status)) { break; } } return return_ss; }
static struct in_addr *lookup_byname_backend(const char *name, int *count) { int fd; struct ip_service *ret = NULL; struct in_addr *return_ip; int j, i, flags = 0; *count = 0; /* always try with wins first */ if (resolve_wins(name,0x20,&ret,count)) { if ( count == 0 ) return NULL; if ( (return_ip = (struct in_addr *)malloc((*count)*sizeof(struct in_addr))) == NULL ) { free( ret ); return NULL; } /* copy the IP addresses */ for ( i=0; i<(*count); i++ ) return_ip[i] = ret[i].ip; free( ret ); return return_ip; } fd = wins_lookup_open_socket_in(); if (fd == -1) { return NULL; } /* uggh, we have to broadcast to each interface in turn */ for (j=iface_count() - 1; j >= 0; j--) { struct in_addr *bcast = iface_n_bcast(j); return_ip = name_query(fd,name,0x20,True,True,*bcast,count, &flags, NULL); if (return_ip) break; } close(fd); return return_ip; }
/******************************************************** resolve via "bcast" method *********************************************************/ static BOOL resolve_bcast (const char *name, struct in_addr *return_ip, int name_type) { int sock, i; /* * "bcast" means do a broadcast lookup on all the local interfaces. */ DEBUG (3, ("resolve_name: Attempting broadcast lookup for name %s<0x%x>\n", name, name_type)); sock = open_socket_in (SOCK_DGRAM, 0, 3, interpret_addr (lp_socket_address ()), True); if (sock != -1) { struct in_addr *iplist = NULL; int count; int num_interfaces = iface_count (); static char so_broadcast[] = "SO_BROADCAST"; set_socket_options (sock, so_broadcast); /* * Lookup the name on all the interfaces, return on * the first successful match. */ for (i = 0; i < num_interfaces; i++) { struct in_addr sendto_ip; /* Done this way to fix compiler error on IRIX 5.x */ sendto_ip = *iface_bcast (*iface_n_ip (i)); iplist = name_query (sock, name, name_type, True, True, sendto_ip, &count, NULL); if (iplist != NULL) { *return_ip = iplist[0]; free ((char *) iplist); close (sock); return True; } } close (sock); } return False; }
/* check to see if nmbd is running on localhost by looking for a __SAMBA__ response */ BOOL nmbd_running(void) { int fd, count, flags; struct in_addr *ip_list; if ((fd = open_socket_in(SOCK_DGRAM, 0, 3, interpret_addr("127.0.0.1"), True)) != -1) { if ((ip_list = name_query(fd, "__SAMBA__", 0, True, True, loopback_ip, &count, &flags, NULL)) != NULL) { SAFE_FREE(ip_list); close(fd); return True; } close (fd); } return False; }
/* check to see if nmbd is running on localhost by looking for a __SAMBA__ response */ bool nmbd_running(void) { struct in_addr loopback_ip; int count; struct sockaddr_storage *ss_list; struct sockaddr_storage ss; NTSTATUS status; loopback_ip.s_addr = htonl(INADDR_LOOPBACK); in_addr_to_sockaddr_storage(&ss, loopback_ip); status = name_query("__SAMBA__", 0, True, True, &ss, talloc_tos(), &ss_list, &count, NULL); if (NT_STATUS_IS_OK(status)) { TALLOC_FREE(ss_list); return True; } return False; }
static bool query_one(const char *lookup, unsigned int lookup_type) { int j, count, flags = 0; struct sockaddr_storage *ip_list=NULL; if (got_bcast) { char addr[INET6_ADDRSTRLEN]; print_sockaddr(addr, sizeof(addr), &bcast_addr); d_printf("querying %s on %s\n", lookup, addr); ip_list = name_query(ServerFD,lookup,lookup_type,use_bcast, use_bcast?true:recursion_desired, &bcast_addr, &count, &flags, NULL); } else { const struct in_addr *bcast; for (j=iface_count() - 1; !ip_list && j >= 0; j--) { char addr[INET6_ADDRSTRLEN]; struct sockaddr_storage bcast_ss; bcast = iface_n_bcast_v4(j); if (!bcast) { continue; } in_addr_to_sockaddr_storage(&bcast_ss, *bcast); print_sockaddr(addr, sizeof(addr), &bcast_ss); d_printf("querying %s on %s\n", lookup, addr); ip_list = name_query(ServerFD,lookup,lookup_type, use_bcast, use_bcast?True:recursion_desired, &bcast_ss,&count, &flags, NULL); } } if (!ip_list) { return false; } if (give_flags) { d_printf("Flags: %s\n", query_flags(flags)); } for (j=0;j<count;j++) { char addr[INET6_ADDRSTRLEN]; if (translate_addresses) { char h_name[MAX_DNS_NAME_LENGTH]; h_name[0] = '\0'; if (sys_getnameinfo((const struct sockaddr *)&ip_list[j], sizeof(struct sockaddr_storage), h_name, sizeof(h_name), NULL, 0, NI_NAMEREQD)) { continue; } d_printf("%s, ", h_name); } print_sockaddr(addr, sizeof(addr), &ip_list[j]); d_printf("%s %s<%02x>\n", addr,lookup, lookup_type); /* We can only do find_status if the ip address returned was valid - ie. name_query returned true. */ if (find_status) { do_node_status(ServerFD, lookup, lookup_type, &ip_list[j]); } } free(ip_list); return (ip_list != NULL); }
move_entry_t::move_entry_t(int version_id, int move_id) { CONNECT_TO_DB(db); if(not entries_created) create_none_invalid_entries(); if(move_id == Moves::NONE) { *this = none_entry; return; } else if(move_id == Moves::INVALID) { *this = invalid_entry; return; } int generation = database::get_generation(version_id); std::ostringstream query_stream; query_stream << "SELECT generation_id FROM moves WHERE id=" << move_id; if(int(db->execAndGet(query_stream.str().c_str())) > generation) throw std::runtime_error("This move did not exist in this generation."); /* * The "moves" table should give us most things. */ query_stream.str(""); query_stream << "SELECT * FROM moves WHERE id=" << move_id; SQLite::Statement moves_query(*db, query_stream.str().c_str()); moves_query.executeStep(); name = database::get_move_name(move_id); type = database::get_type_name(moves_query.getColumn(3)); // type_id damage_class = database::get_move_damage_class_name(int(moves_query.getColumn(9))); // damage_class_id power = moves_query.getColumn(4); // power pp = moves_query.getColumn(5); // pp accuracy = float(moves_query.getColumn(6)) / float(100.0); // accuracy priority = moves_query.getColumn(7); // priority // effect = effect_chance = float(moves_query.getColumn(11)) / float(100.0); // effect_chance /* * Description */ query_stream.str(""); query_stream << "SELECT flavor_text FROM move_flavor_text WHERE move_id=" << move_id << " AND language_id=9 AND version_group_id=" << database::get_version_group_id(version_id); SQLite::Statement flavor_text_query(*db, query_stream.str().c_str()); try { description = get_pkstring_from_query(flavor_text_query); } catch(...) { description = "Unavailable"; } /* * Target */ query_stream.str(""); query_stream << "SELECT name FROM move_target_prose WHERE move_target_id=" << moves_query.getColumn(8) << " AND local_language_id=9"; // target_id SQLite::Statement move_target_prose_query(*db, query_stream.str().c_str()); target = get_pkstring_from_query(move_target_prose_query); /* * Effect * TODO: parse tokens in short_effect */ query_stream.str(""); query_stream << "SELECT short_effect FROM move_effect_prose WHERE move_effect_id=" << moves_query.getColumn(10); // effect_id SQLite::Statement move_effect_prose_query(*db, query_stream.str().c_str()); effect = get_pkstring_from_query(move_effect_prose_query); /* * Contest type */ query_stream.str(""); query_stream << "SELECT name FROM contest_type_names WHERE contest_type_id=" << moves_query.getColumn(12) << " AND local_language_id=9"; // contest_type_id SQLite::Statement contest_type_names_query(*db, query_stream.str().c_str()); contest_type = get_pkstring_from_query(contest_type_names_query); /* * Contest effect */ query_stream.str(""); query_stream << "SELECT flavor_text FROM contest_effect_prose WHERE contest_effect_id=" << moves_query.getColumn(13) << " AND local_language_id=9"; // contest_effect_id SQLite::Statement contest_effect_prose_query(*db, query_stream.str().c_str()); contest_effect = get_pkstring_from_query(contest_effect_prose_query); /* * Super Contest effect */ query_stream.str(""); query_stream << "SELECT flavor_text FROM super_contest_effect_prose" << " WHERE super_contest_effect_id=" << moves_query.getColumn(14) << " AND local_language_id=9"; // super_contest_effect_id SQLite::Statement super_contest_effect_prose_query(*db, query_stream.str().c_str()); super_contest_effect = get_pkstring_from_query(super_contest_effect_prose_query); /* * Database values are valid for Generation VI, this fixes entries * from earlier generations. */ if(generation < 6) { std::ostringstream query_stream; query_stream << "SELECT gen" << generation << "_accuracy FROM old_move_accuracies WHERE move_id=" << move_id; SQLite::Statement accuracy_query(*db, query_stream.str().c_str()); if(accuracy_query.executeStep()) accuracy = float(accuracy_query.getColumn(0)) / 100.0; // Hypnosis varies in accuracy between games if(move_id == Moves::HYPNOSIS and (version_id == Versions::DIAMOND or version_id == Versions::PEARL)) accuracy = 0.7f; query_stream.str(""); query_stream << "SELECT gen" << generation << "_power FROM old_move_powers WHERE move_id=" << move_id; SQLite::Statement power_query(*db, query_stream.str().c_str()); if(power_query.executeStep()) power = power_query.getColumn(0); // Shadow Rush varies in power between Gamecube games if(move_id == Moves::SHADOW_RUSH and version_id == Versions::COLOSSEUM) power = 90; query_stream.str(""); query_stream << "SELECT gen" << generation << "_pp FROM old_move_pps WHERE move_id=" << move_id; SQLite::Statement pp_query(*db, query_stream.str().c_str()); if(pp_query.executeStep()) pp = pp_query.getColumn(0); // Not enough type changes to warrant a database table if(generation == 1) { if(move_id == Moves::BITE or move_id == Moves::GUST or move_id == Moves::KARATE_CHOP or move_id == Moves::SAND_ATTACK) type = "Normal"; } else if(move_id == Moves::CURSE and generation < 4) type = "???"; else if(move_id == Moves::CHARM or move_id == Moves::MOONLIGHT or move_id == Moves::SWEET_KISS) type = "Normal"; // Only one move changes categories before Generation IV if(generation == 1 and move_id == Moves::BITE) damage_class = "Physical"; // TODO: targeting changes, making contact query_stream.str(""); query_stream << "SELECT gen" << generation << "_priority FROM old_move_priorities WHERE move_id=" << move_id; SQLite::Statement priority_query(*db, query_stream.str().c_str()); if(priority_query.executeStep()) priority = priority_query.getColumn(0); // Only one move changed name between Generation II-III if(move_id == Moves::CONVERSION_2 and generation < 3) name = "Conversion2"; query_stream.str(""); query_stream << "SELECT name FROM old_move_names WHERE move_id=" << move_id; SQLite::Statement name_query(*db, query_stream.str().c_str()); if(name_query.executeStep()) name = name_query.getColumn(0); if(generation != 4) super_contest_effect = "None"; if(generation < 4) { query_stream.str(""); query_stream << "SELECT name FROM move_damage_class_prose WHERE local_language_id=9" << " AND move_damage_class_id=(SELECT damage_class_id FROM types WHERE" << " id=" << database::get_type_id(type) << ")"; std::string damage_class_name = db->execAndGet(query_stream.str().c_str()); damage_class_name[0] = ::toupper(damage_class_name[0]); damage_class = damage_class_name; } if(generation < 3) { contest_type = "None"; contest_effect = "None"; } } }