Changer adresse ip en c++

Bonjour,

Je cherche à faire un programme en c++ qui me permet de changer l'adresse ip de ma machine. Je ne connais pas grand chose à la programmation Windows et je suis vraiment paumé 8O :oops: alors si quelqu'un avait un petit exemple de code source, cela me dépannerait grandement.

Merci.
Nicopelo

je ne sais pas comment faire mais a force de chercher des infos sur les APIs windows(t'es bien sous windows?) j'ai un reflexe c'est google avec les mots clefs en anglais du genre pour toi je mettrais :

msdn+change+ip
ou API+windows+change+ip
et tu tournes autour ensuite avec ce que tu trouves sur les forums ou sur le msdn carrement ;) ! ca prend du temps mais tu finis par y arriver;)

Vi vi, je suis bien sous Windows, XP pour être + précis (et si ça une importance).
En fait, j'ai commencé par faire une recherche google avant de me pencher sur le postage de message mais je n'est pas trouvé ce que je cherche. J'ai trouvé de nombreuses réponses mais qui utilisaient les langages VB ou encore C#, mais absolument rien en ce qui concerne C++. J'ai donc essayé d'utiliser les objets utilisés dans ces langages mais je ne sais pas si les objets portent le même nom et ont les mêmes méthodes dans les différents langages faisant parti du "bouquet" .net. Par exemple, en C#, il faut utiliser l'objet ObjectQuery que tu donnes en paramètre au constructeur de ManagementObjectSearcher mais j'ai alors des problèmes d'include si ces objets existent bel et bien en C++, ce dont je doute.

recherches des librairie c++ de reseau peut etre (network library ;) )

Malheureusement, non.
Et le pire, c'est que je ne trouve rien non plus sur le site de msdn...:( :cry:

désolé je ne peux pas t'aider plus! je n'ai pas le temps de faire des recherches, je suis déjà bien acaparé par les miennes(quel galere :aie: )

bon courage ;)

Je ne souhaitais pas que tu recherches à ma place, simplement un bout de code venant de quelqu'un qui avait déjà programmer ce genre de truc...
Merci quand même pour le temps que tu m'as consacré...

Tu peux pas changer d'adresse IP.
C ton FAI qui te l'attribu, tu n'as pas de pouvoir la dessus...
Tu peux essayer de la changer en passant par un serveur, mais il y a toujours moyen de te retrouver, car a la base, les données sont bien ré-envoyées sur la tienne...

C comme si tu voulais changer de numero de telephone :
Tu peux faire un transfert d'appel: ainsi l'interlocuteur aurra le numero de l'appareil qui fait le transfert, mais il faut quand meme que l'appel soit ré-envoyer sur ton vrai numero. Donc si ton programme a pour but de permettre de rester anonyme, c impossible car on pourra toujours retracer par qui et ou a ete redirigé l'appel.

Jespere que l'exemple te permet de bien comprendre, et de capter qu'il n'y a pas de scripts magique pour ça :)

Et bien j'ai du mal m'exprimer. En fait, je voudrais changer l'adresse ip de ma machine au sein de mon réseau local ; je ne cherches absolument pas faire un logiciel d'anonymat. J'ai bien compris que si je change mon adresse extérieure, je ne pourrais jamais recevoir les paquets qui me sont envoyé. Et je suis en ip fixe de toutes façons...

J'ai donc fini par trouver, après beaucoup de souffrance :mouarf: !
La seule solution consiste à passer par WMI.

Voici donc le code correspondant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
// C'est parti !!!
IWbemLocator *pLocator = NULL;
HRESULT hres;
BSTR bstrPath;
IWbemServices *pNamespace = NULL;
LPWSTR wcsConnection = _T("Local Area Connection");
BSTR bstrQuery = NULL;
WCHAR *wcsQuery = NULL;
BSTR bstrWQL = NULL;
BSTR bstrNetworkAdapterQuery = NULL;
IEnumWbemClassObject *pEnumAdapter;
IWbemClassObject *pObjAdapter; // Objet Win32_NetworkAdapter
ULONG ulCountAdapter;
VARIANT var;
LPWSTR wqlConfig = _T("ASSOCIATORS OF {Win32_NetworkAdapter.DeviceID=\"%s\"} WHERE ResultClass = Win32_NetworkAdapterConfiguration");
IEnumWbemClassObject *pEnumConfig;
IWbemClassObject *pObjConfig; // Objet Win32_NetworkAdapterConfiguration
IWbemClassObject *pObjNetConfig;
ULONG ulCountConfig;
BSTR bstrObjectPath;
BSTR bstrClassPath;
long lReturnValue;
PMIB_IPADDRTABLE pIPAddrTable;
DWORD dwSize = 0;
DWORD dwMask = 0;
DWORD dwRetVal = 0;
//LPWSTR wcsMask = NULL;
WCHAR wcsMask[128];
IWbemClassObject *pMethod = NULL;
IWbemClassObject *pInParam = NULL;
BSTR *pbstr = NULL;
SAFEARRAY *psa = NULL;
SAFEARRAYBOUND rgsabound;
LONG lstart;
LONG lend;
LONG idx;
SAFEARRAY *sa = NULL;
                        
// Initialisation du runtime COM
hres = CoInitialize(NULL);

if (SUCCEEDED(hres))
  {
    // Niveau de sécurité
    hres = CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL);
  }
						
if (SUCCEEDED(hres))
  {
    // Création de l'instance IWbemLocator
    hres = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_ALL, IID_IWbemLocator, (LPVOID *)&pLocator);
  }
						
if (SUCCEEDED(hres))
  {
    // Connexion à root\cimv2
    bstrPath = SysAllocString(L"ROOT\\CIMV2");
    hres = pLocator->ConnectServer(bstrPath, NULL, NULL, NULL, 0, NULL, NULL, &pNamespace);
							
    SysFreeString(bstrPath);
    pLocator->Release();
  }
                        
if (SUCCEEDED(hres))
  {
    // Paramètrage du niveau d'authentification du proxy (niveau nul)
    hres = CoSetProxyBlanket(pNamespace, RPC_C_AUTHN_DEFAULT, RPC_C_AUTHZ_DEFAULT, COLE_DEFAULT_PRINCIPAL, RPC_C_AUTHN_LEVEL_CONNECT, RPC_C_IMP_LEVEL_IMPERSONATE, COLE_DEFAULT_AUTHINFO, EOAC_NONE);
  }
                        
if (SUCCEEDED(hres))
  {
    //
    // Désormais, il faut s'occuper de la requete Win32_NetworkAdapter afin de retrouver la Win32_NetworkAdapterConfiguration associée
    //
							
    bstrWQL = SysAllocString(_T("WQL"));
    bstrNetworkAdapterQuery = SysAllocString(_T("SELECT * FROM Win32_NetworkAdapter WHERE NetConnectionStatus=2"));
                            
    // Execution de la requette d'interrogation du système : SELECT * FROM Win32_NetworkAdapter WHERE ...
    hres = pNamespace->ExecQuery(bstrWQL, bstrNetworkAdapterQuery, WBEM_FLAG_FORWARD_ONLY, NULL, &pEnumAdapter);
  }
                        
if (SUCCEEDED(hres))
  {
    // Récupération de la valeur : Win32_NetworkAdapter
    hres = pEnumAdapter->Next(WBEM_INFINITE, 1, &pObjAdapter, &ulCountAdapter);
    pEnumAdapter->Release();
  }
                        
if (SUCCEEDED(hres))
  {
    // Récupération du DeviceID du Win32_NetworkAdapter
    hres = pObjAdapter->Get(_T("DeviceID"), 0, &var, NULL, NULL);
    pObjAdapter->Release();
  }
                        
if (SUCCEEDED(hres))
  {
    if (VT_BSTR != var.vt) // Une erreur s'est produite
      {
	pObjAdapter->Release();
	hres = TYPE_E_TYPEMISMATCH;
      }
    else
      {
	// Allocation et construction de la requete de configuration : ASSOCIATORS OF {Win32_NetworkAdapter.DeviceID="..."} WHERE ResultClass = Win32_NetworkAdapterConfiguration
	wcsQuery = (WCHAR *)HeapAlloc(GetProcessHeap(), 0, (wcslen(var.bstrVal) + wcslen(wqlConfig) + 1) * sizeof(WCHAR));
	wsprintfW(wcsQuery, wqlConfig, var.bstrVal);
	bstrQuery = SysAllocString(wcsQuery);
	HeapFree(GetProcessHeap(), 0, wcsQuery);
	VariantClear(&var);
    							
	// Execution de la requete : ASSOCIATORS OF {Win32_NetworkAdapter.DeviceID="..."} WHERE ResultClass = Win32_NetworkAdapterConfiguration
	hres = pNamespace->ExecQuery(bstrWQL, bstrQuery, WBEM_FLAG_FORWARD_ONLY, NULL, &pEnumConfig);
	SysFreeString(bstrQuery);
      }
  }
                        
if (SUCCEEDED(hres))
  {
    // Récupération de la valeur : Win32_NetworkAdapterConfiguration
    hres = pEnumConfig->Next(WBEM_INFINITE, 1, &pObjConfig, &ulCountConfig);
    pEnumConfig->Release();
  }
                        
if (SUCCEEDED(hres))
  {
    //
    // Récupération du nom de la classe et du chemin relatif de l'objet Win32_NetworkAdapterConfiguration
    //
							
    // Récupération du chemin relatif
    hres = pObjConfig->Get(_T("__RELPATH"), 0, &var, 0, NULL);
  }
                        
if (SUCCEEDED(hres))
  {
    if (VT_BSTR != var.vt) // Une erreur s'est produite
      {
	pObjConfig->Release();
	hres = TYPE_E_TYPEMISMATCH;
      }
    else
      {
	bstrObjectPath = SysAllocString(var.bstrVal);
	VariantClear(&var);
								
	// Récupération du nom de la classe
	hres = pObjConfig->Get(_T("__CLASS"), 0, &var, 0, NULL);
      }
  }
                        
if (SUCCEEDED(hres))
  {
    if (VT_BSTR != var.vt) // Une erreur s'est produite
      {
	pObjConfig->Release();
	hres = TYPE_E_TYPEMISMATCH;
      }
    else
      {
	bstrClassPath = SysAllocString(var.bstrVal);
	VariantClear(&var);
      }
  }
                        
if (SUCCEEDED(hres))
  {
    // Récupération du masque de sous réseau
    hres = pObjConfig->Get(_T("IPSubnet"), 0, &var, 0, NULL);
    sa = var.parray;
                            
    hres = SafeArrayGetLBound(sa, 1, &lstart);
  }
                        
if (SUCCEEDED(hres))
  {
    hres = SafeArrayGetUBound(sa, 1, &lend);
  }
                        
if (SUCCEEDED(hres))
  {
    hres = SafeArrayAccessData(sa, (void HUGEP**)&pbstr);
  }

if (SUCCEEDED(hres))
  {
    for (idx = lstart ; idx <= lend ; idx++)
      {
	::_tcscpy(wcsMask, pbstr[idx]);
      }
    hres = SafeArrayUnaccessData(sa); 
  }
                            
if (SUCCEEDED(hres))
  {
    VariantClear(&var);
                            
    // On en a terminé avec Win32_NetworkAdapterConfiguration, on le libère donc
    pObjConfig->Release();
							
    //
    // Appel à NetworkAdapterConfiguration.EnableStatic
    //
							
    // Récupération de l'objet pour invoquer la méthode
    hres = pNamespace->GetObject(bstrClassPath, 0, NULL, &pObjNetConfig, NULL);
  }
                        
if (SUCCEEDED(hres))
  {
    // Récupération de la méthode EnableStatic ; on ne s'interesse que à la signature d'entrée
    hres = pObjNetConfig->GetMethod(_T("EnableStatic"), 0, &pMethod, NULL);
    pObjNetConfig->Release();
  }
                        
if (SUCCEEDED(hres))
  {
    // Appel d'une nouvelle instance pour les paramètres d'entrée
    hres = pMethod->SpawnInstance(0, &pInParam);
    pMethod->Release();
  }
                        
if (SUCCEEDED(hres))
  {
    // Signature : EnableStatic( string IPAddress[], SubnetMask[])
    rgsabound.cElements = 1;
    rgsabound.lLbound = 0;
							
    // Initialisation des paramètres de l'adresse ip
    psa = SafeArrayCreate(VT_BSTR, 1, &rgsabound);
    SafeArrayAccessData(psa, (void **)&pbstr);
    *pbstr = SysAllocString(wsAdresseIp.c_str());
    SafeArrayUnaccessData(psa);
    V_VT(&var) = VT_ARRAY | VT_BSTR;
    V_ARRAY(&var) = psa;
							
    // Affectation de la valeur de l'adresse ip
    hres = pInParam->Put(_T("IPAddress"), 0, &var, 0);
    VariantClear(&var);
  }
                        
if (SUCCEEDED(hres))
  {
    // Initialisation des paramètres du masque de sous réseau
    psa = SafeArrayCreate(VT_BSTR, 1, &rgsabound);
    SafeArrayAccessData(psa, (void **)&pbstr);
    *pbstr = SysAllocString(wcsMask);
    SafeArrayUnaccessData(psa);
    V_VT(&var) = VT_ARRAY | VT_BSTR;
    V_ARRAY(&var) = psa;
							
    // Affectation de la valeur du masque de sous réseau
    hres = pInParam->Put(_T("SubnetMask"), 0, &var, 0);
    VariantClear(&var);
  }
                        
if (SUCCEEDED(hres))
  {
    // Appel de la méthode
    IWbemClassObject *pOutParam = NULL;
    hres = pNamespace->ExecMethod(bstrObjectPath, _T("EnableStatic"), 0, NULL, pInParam, &pOutParam, NULL);			// IWbemCallResult** ppCallResult
    pInParam->Release();
							
    if (SUCCEEDED(hres))
      {
	// Récupération de la valeur de retour
	hres = pOutParam->Get(_T("ReturnValue"), 0, &var, NULL, 0);
	pOutParam->Release();
								
	if (SUCCEEDED(hres))
	  {
	    lReturnValue = var.lVal;
	    VariantClear(&var);
	  }
      }
  }
						
if (bstrClassPath != NULL)
  {
    SysFreeString(bstrClassPath);
  }
						
if (bstrObjectPath != NULL)
  {
    SysFreeString(bstrObjectPath);
  }
						
if (pNamespace != NULL)
  {
    pNamespace->Release();
  }
						
if (bstrWQL != NULL)
  {
    SysFreeString(bstrWQL);
  }

Pour être honnete, WMI n'est pas ce qu'il y a de plus simple à comprendre mais bon, si moi j'ai réussi...

Au plaisir