Détermination de l'adresse IP d'un client connecté sur le serveur

J'ai un serveur en cours d'exécution sur un ordinateur et que vous avez le port qu'il utilise transmis à mon routeur, et un autre ordinateur exécutant le client de la connexion au serveur à l'aide de mon FAI attribué l'adresse IP externe au lieu de l'adresse locale. Tout cela fonctionne très bien et il se connecte mais Quand je vérifie l'adresse de la socket connecté (client), L'adresse IP qu'il montre est complètement différent? il me montre 148.49.68.0. Je ne trouve pas cela sur ipconfig et ne comprends pas d'où c'est popping up. Ne pas le client de montrer mon adresse externe? (vu que les deux ordinateurs utilisent la même adresse IP Externe).

[MODIFIER] ajouté serveur source

#include <iostream>
#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <string.h>
using namespace std;
int PORT;
const int winsock_version = 2;
const int max_con = 10;
string SERVER_ADDRS;
void Bind(SOCKET &serv,struct sockaddr_in &serv_info,int size);
void Listen(SOCKET &serv,int max_con);
void connection_info(struct sockaddr_in &client);
bool communication(SOCKET &client); 
SOCKET Accept(SOCKET &serv);
int main(void){
WSADATA wsadata;
if ( WSAStartup(MAKEWORD(winsock_version,0),&wsadata) == 0 ){
cout<<"-[Initialized.]" << endl;
cout<<"-[Server Address (leave blank to scan for all IP's)]: ";
getline(cin,SERVER_ADDRS);
cout<<"-[Port]: ";
cin>>PORT;
struct sockaddr_in serv_info;
serv_info.sin_family = AF_INET;
serv_info.sin_port = htons(PORT);
if( sizeof(SERVER_ADDRS) > 5 ){
cout<<"-[Listening on: " << SERVER_ADDRS << "]" << endl;
serv_info.sin_addr.s_addr = inet_addr(SERVER_ADDRS.c_str());
}else{
cout<<"-[Scanning for All IP's]" << endl;
serv_info.sin_addr.s_addr = INADDR_ANY;
}
SOCKET serv;
serv = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if ( serv != INVALID_SOCKET ){
//------------------------------------------------------------
Bind(serv,serv_info,sizeof(serv_info));
Listen(serv,max_con);
struct sockaddr_in client_info;
int size = sizeof(client_info);
SOCKET client_sock = Accept(serv);
connection_info(client_info);
if (communication(client_sock) == true){
closesocket(serv);
closesocket(client_sock);
}
//------------------------------------------------------------
}
}else{
cout<<"-[Initialization failed, running cleanup.]" << endl;
}
if (WSACleanup() == 0){
cout<<"-[Cleanup Successful.]" << endl;
}
return 0;
}
void Bind(SOCKET &serv,struct sockaddr_in &serv_info,int size){
if ( bind(serv,(sockaddr*)&serv_info,size) != -1 ){
//Binding complete, now clear the port and allow for reuse if needed using setsockopt
char yes = '1';
if ( setsockopt(serv,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes)) != SOCKET_ERROR){
cout<<"-[Binding Successful.]" << endl;
}
}
}
void Listen(SOCKET &serv,int max_con){
if ( listen(serv,max_con) != -1 ){
cout<<"-[Listening for connections.] " << endl;
}
}
SOCKET Accept(SOCKET &serv){
struct sockaddr_in client_info;
int size = sizeof(client_info);
SOCKET recv;
recv = accept(serv,(sockaddr*)&client_info,&size);
if (recv != INVALID_SOCKET ) {
return recv;
}else{
cout<<"-[Invalid Socket.]" << endl;
}
}
void connection_info(struct sockaddr_in &client){
char *connected_ip= inet_ntoa(client.sin_addr); 
int port = ntohs(client.sin_port);
cout<<"-[IP:" << connected_ip <<", Connected on PORT:"<< port  << "]"<< endl;
}
bool communication(SOCKET &client){
cout<<"[---------------{CHAT}---------------]" << endl;
int bytes_in;
int bytes_out;
char recvd_text[80];
string send_text;
while(true){
cout<<"-[SERVER]: ";
getline(cin,send_text);
if (sizeof(send_text) > 0 ){
bytes_out = send(client,send_text.c_str(),send_text.length()+1,0);
cout<< endl;
if (bytes_out == SOCKET_ERROR){
cout<<"-[SERVER error in sending.]" << endl;
break;
}
}
bytes_in = recv(client,recvd_text,sizeof(recvd_text),0);
if (bytes_in > 0 ){
cout<<"-[CLIENT]: " << recvd_text << endl;  //output on screen
}
if (bytes_in == 0){
cout<<"-[CLIENT has disconnected.]" << endl;
break;
}
if (bytes_in == SOCKET_ERROR){
cout<<"-[CLIENT closed unexpectedly.]" << endl; 
break;
}
}
return true;
}

148.49.68.0 => DoD Centre d'Information du Réseau, Columbus OH.

OriginalL'auteur silent | 2010-11-26

c++client-server ip ip-address winsock

Essayez ceci:

#include <iostream>
#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <string>
int PORT;
const int winsock_version = 2;
const int max_con = 10;
std::string SERVER_ADDRS;
void Bind(SOCKET &serv, const struct sockaddr_in &serv_info);
void Listen(SOCKET &serv, int max_con);
void connection_info(struct sockaddr_in &client);
bool communication(SOCKET client);
SOCKET Accept(SOCKET serv, sockaddr_in &client_info); 
int main(void)
{
WSADATA wsadata; 
if ( WSAStartup(MAKEWORD(winsock_version,0),&wsadata) == 0 )
{ 
std::cout << "-[Initialized.]" << std::endl; 
std::cout << "-[Server Address (leave blank to scan for all IP's)]: "; 
std::getline(std::cin, SERVER_ADDRS); 
std::cout << "-[Port]: "; 
std::cin >> PORT; 
struct sockaddr_in serv_info = {0}; 
serv_info.sin_family = AF_INET; 
serv_info.sin_port = htons(PORT); 
if( SERVER_ADDRS.length() > 0 )
{ 
std::cout << "-[Listening on: " << SERVER_ADDRS << "]" << std::endl; 
serv_info.sin_addr.s_addr = inet_addr(SERVER_ADDRS.c_str()); 
}
else
{ 
std::cout << "-[Scanning for All IP's]" << std::endl; 
serv_info.sin_addr.s_addr = INADDR_ANY; 
} 
SOCKET serv = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 
if ( serv != INVALID_SOCKET )
{ 
//------------------------------------------------------------ 
Bind(serv, serv_info); 
Listen(serv, max_con); 
struct sockaddr_in client_info = {0}; 
SOCKET client_sock = Accept(serv, client_info);
if ( client_sock != INVALID_SOCKET )
{
connection_info(client_info); 
communication(client_sock);
closesocket(client_sock); 
}
//------------------------------------------------------------ 
closesocket(serv); 
} 
if (WSACleanup() == 0)
{ 
std::cout << "-[Cleanup Successful.]" << std::endl; 
}
}
else
{ 
std::cout << "-[Initialization failed.]" << std::endl; 
} 
return 0; 
} 
void Bind(SOCKET serv, const struct sockaddr_in &serv_info)
{ 
//clear the port and allow for reuse before binding it
int yes = 1; 
if ( setsockopt(serv, SOL_SOCKET, SO_REUSEADDR, (char*)&yes, sizeof(yes)) != SOCKET_ERROR)
{
std::cout << "-[Reuse Address Successful.]" << std::endl; 
}
if ( bind(serv, (sockaddr*)&serv_info, sizeof(serv_info)) != -1 )
{ 
std::cout << "-[Binding Successful.]" << std::endl; 
} 
} 
void Listen(SOCKET serv, int max_con)
{ 
if ( listen(serv, max_con) != -1 )
{ 
std::cout << "-[Listening for connections.] " << std::endl; 
} 
} 
SOCKET Accept(SOCKET &serv, sockaddr_in &client_info)
{ 
int size = sizeof(client_info); 
SOCKET recv = accept(serv, (sockaddr*)&client_info, &size); 
if ( recv == INVALID_SOCKET )
{ 
std::cout << "-[Invalid Socket.]" << std::endl; 
} 
return recv; 
} 
void connection_info(struct sockaddr_in &client)
{ 
char *connected_ip = inet_ntoa(client.sin_addr);
int port = ntohs(client.sin_port); 
st::cout << "-[IP:" << connected_ip << ", Connected on PORT:" << port << "]" << std::endl; 
} 
bool communication(SOCKET client)
{ 
std::cout << "[---------------{CHAT}---------------]" << std::endl; 
int bytes_in; 
int bytes_out; 
char recvd_text[81]; 
std::string send_text; 
while(true)
{ 
std::cout << "-[SERVER]: "; 
std::getline(std::cin,send_text); 
if (send_text.length() > 0 )
{ 
bytes_out = send(client, send_text.c_str(), send_text.length()+1, 0); 
std::cout << std::endl; 
if (bytes_out == SOCKET_ERROR)
{ 
std::cout << "-[SERVER error in sending.]" << std::endl; 
break; 
} 
} 
bytes_in = recv(client, recvd_text, sizeof(recvd_text)-1, 0); 
if (bytes_in == SOCKET_ERROR)
{ 
std::cout << "-[CLIENT closed unexpectedly.]" << std::endl; 
break; 
} 
else if (bytes_in == 0)
{ 
std::cout << "-[CLIENT has disconnected.]" << std::endl; 
break; 
} 
else
{
recvd_text[bytes_in] = 0;
std::cout << "-[CLIENT]: " << recvd_text << std::endl;  //output on screen 
}
} 
return true; 
}

OriginalL'auteur Remy Lebeau

0

Le WinSock getsockname() et getpeername() fonctions de retour au local et à distance IPs de la socket connecté, respectivement. En supposant que vous utilisez déjà, alors s'il vous plaît montrer votre code, que vous êtes susceptibles de ne pas les utiliser correctement.

Bonjour, je n'ai pas utilisé getsockname ou getpeername, j'ai pensé que la structure sockaddr reçu pour le serveur sur le client aurait déjà. Je vais éditer le post ci-dessus, veuillez en informer moi comment.
Oui, accept() retourne des informations sur le client connecté. Cependant, il y a quelques bugs dans votre code. Le plus important bug lié à votre question de départ, c'est que votre Accept() de la fonction de récupération de l'info client dans un sockaddr_in variable locale de n'Accepter que les(), mais alors votre connection_info() la fonction est d'afficher les valeurs à partir d'un autre sockaddr_in local à main() à la place et n'a jamais été rempli avec des données, de sorte que vous êtes en affichage aléatoire d'ordures. Votre Accept() la fonction doit retourner le sockaddr_in données récupérées, jetez pas.

OriginalL'auteur Remy Lebeau

Détermination de l'adresse IP d'un client connecté sur le serveur

Un c/c++ de manière à obtenir des ip externe est d'utiliser un site web en fonction de l'adresse IP de l'API outil de téléchargement de la page web contenant votre adresse IP dans un tableau de char et d'en extraire l'adresse IP de la source HTML. Voici quelques winsock code pour le démontrer. il utilise http://api.ipify.org/ en ligne de l'api web.

//
//Winsock get external ip address from website api at   api.ipify.org
//api.ipify.org
//
#include <string.h>
#include <stdio.h>
#include <winsock2.h>
#include <windows.h>
#include <iostream>
#include <vector>
#include <algorithm>
#include <cctype>
#include <locale>
#include <fstream>
#include <ctime>
#include <cstdlib>
using namespace std;
#pragma comment(lib,"ws2_32.lib")
string website_HTML;
locale local;
char ipaddress[16];
int ic=0;
void get_Website(char *url );
char mystring[] = " ";
char seps[]   = " ,\t\n";
char *token;
char lineBuffer[200][80] ={' '};
char buffer[10000];
char ip_address[16];
int i = 0, bufLen=0, j=0,lineCount=0;
int lineIndex=0, posIndex=0;
int main( void ){
SYSTEMTIME st;
GetLocalTime(&st);
char *today = new char[32];
memset(today,' ', sizeof(today) );
sprintf(today,"%d-%d-%d", st.wYear , st.wMonth , st.wDay);
memset(buffer,'\0',sizeof(buffer));
get_Website("api.ipify.org" );
for (size_t i=0; i<website_HTML.length(); ++i) website_HTML[i]= tolower(website_HTML[i],local);
token = strtok( buffer , seps );  
while( token != NULL ){
strcpy(lineBuffer[lineIndex],token);
int dot=0;
for (int ii=0; ii< strlen( lineBuffer[lineIndex] ); ii++ ){
if (lineBuffer[lineIndex][ii] == '.') dot++;
if (dot>=3){
dot=0;
strcpy(ip_address,lineBuffer[lineIndex]);
}
}
token = strtok( NULL, seps );       
lineIndex++;
}
cout<<"Your IP Address is  "<< ip_address<<" \n\n";
return 0;
}
void get_Website(char *url ){
WSADATA wsaData;
SOCKET Socket;
SOCKADDR_IN SockAddr;
int lineCount=0;
int rowCount=0;
struct hostent *host;
char *get_http= new char[256];
memset(get_http,' ', sizeof(get_http) );
strcpy(get_http,"GET /HTTP/1.1\r\nHost: ");
strcat(get_http,url);
strcat(get_http,"\r\nConnection: close\r\n\r\n");
if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0){
cout << "WSAStartup failed.\n";
system("pause");
//return 1;
}
Socket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
host = gethostbyname(url);
SockAddr.sin_port=htons(80);
SockAddr.sin_family=AF_INET;
SockAddr.sin_addr.s_addr = *((unsigned long*)host->h_addr);
if(connect(Socket,(SOCKADDR*)(&SockAddr),sizeof(SockAddr)) != 0){
cout << "Could not connect";
system("pause");
//return 1;
}
send(Socket,get_http, strlen(get_http),0 );
int nDataLength;
while ((nDataLength = recv(Socket,buffer,10000,0)) > 0){        
int i = 0;
while (buffer[i] >= 32 || buffer[i] == '\n' || buffer[i] == '\r'){
website_HTML+=buffer[i];
i += 1;
}               
}
closesocket(Socket);
WSACleanup();
delete[] get_http;
}

Ce n'est pas ce qu'il demandait. Ce que vous faites, vous êtes à la récupération de quelqu'un public IP. Plus loin encore, êtes-vous sûr que le ipify.org service sera autour de votre approche du travail?

OriginalL'auteur Software_Designer

(Le suivant est spécifique de Windows.)

Que AF_INET6 type de prise peut être configuré pour accepter à la fois IPv4 et IPv6 connexions sur le même port:

int ipv6only = 0;
setsockopt(hSock, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&ipv6only, sizeof(ipv6only));

Je voudrais mettre en œuvre la récupération de la connexion du client stats en tant que tel, juste après la accept fonction:

char Sadr[max(sizeof(sockaddr_in), sizeof(sockaddr_in6))] = {0};
int ncbSzSadr = sizeof(Sadr);
if(getpeername(hSockAccept, (sockaddr*)Sadr, &ncbSzSadr) == 0)
{
if(ncbSzSadr == sizeof(sockaddr_in))
{
//IPv4
sockaddr_in* psadr_v4 = (sockaddr_in*)Sadr;
print("Connected to client from %s, port %u...\n", 
inet_ntoa(psadr_v4->sin_addr),
(int)htons(psadr_v4->sin_port));
}
else if(ncbSzSadr == sizeof(sockaddr_in6))
{
//IPv6
sockaddr_in6* psadr_v6 = (sockaddr_in6*)Sadr;
WCHAR buff[256];
PCTSTR p_strIpv6 = InetNtop(AF_INET6, psadr_v6->sin6_addr, buff, _countof(buff));
_tprintf(L"Connected to client from %s, port %u...\n", 
p_strIpv6,
(int)htons(psadr_v6->sin6_port));
}
else
{
_tprintf(L"ERROR: getpeername bad size=%d\n", ncbSzSadr);
}
}
else
{
_tprintf(L"ERROR: (%d) getpeername\n", WSAGetLastError());
}

Noter que le numéro de port signalé sera pour la connexion sur le côté client (et non pas le côté serveur où ce code est en cours d'exécution.)

Et, par ailleurs, si vous souhaitez récupérer les mêmes informations, mais sur le serveur-côté de la connexion, utiliser le même code, mais remplacer getpeername avec getsockname.

OriginalL'auteur ahmd0

Vous devez vous connecter pour publier un commentaire.